Rename *AsmOperandRef::Const to Interpolate

This is used for string interpolation currently, so rename it as so.
The name `Const` will be used to denote a general CTFE constant that
can either be integer or pointer.

Author: nbdd0121

compiler/rustc_codegen_gcc/src/asm.rs

@@ -294,7 +294,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     }
                 }
 
-                InlineAsmOperandRef::Const { ref string } => {
+                InlineAsmOperandRef::Interpolate { ref string } => {
                     constants_len += string.len() + att_dialect as usize;
                 }
 
@@ -409,7 +409,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     });
                 }
 
-                InlineAsmOperandRef::Const { .. } => {
+                InlineAsmOperandRef::Interpolate { .. } => {
                     // processed in the previous pass
                 }
 
@@ -502,7 +502,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                             template_str.push_str(name);
                         }
 
-                        InlineAsmOperandRef::Const { ref string } => {
+                        InlineAsmOperandRef::Interpolate { ref string } => {
                             template_str.push_str(string);
                         }
 
@@ -865,7 +865,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 }
                 InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
-                        GlobalAsmOperandRef::Const { ref string } => {
+                        GlobalAsmOperandRef::Interpolate { ref string } => {
                             // Const operands get injected directly into the
                             // template. Note that we don't need to escape %
                             // here unlike normal inline assembly.

compiler/rustc_codegen_llvm/src/asm.rs

@@ -205,7 +205,7 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                                 template_str.push_str(&format!("${{{}}}", op_idx[&operand_idx]));
                             }
                         }
-                        InlineAsmOperandRef::Const { ref string } => {
+                        InlineAsmOperandRef::Interpolate { ref string } => {
                             // Const operands get injected directly into the template
                             template_str.push_str(string);
                         }
@@ -398,7 +398,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
                 InlineAsmTemplatePiece::String(ref s) => template_str.push_str(s),
                 InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
-                        GlobalAsmOperandRef::Const { ref string } => {
+                        GlobalAsmOperandRef::Interpolate { ref string } => {
                             // Const operands get injected directly into the
                             // template. Note that we don't need to escape $
                             // here unlike normal inline assembly.

compiler/rustc_codegen_ssa/src/base.rs

@@ -440,14 +440,14 @@ where
                                 const_value,
                                 cx.layout_of(ty),
                             );
-                            GlobalAsmOperandRef::Const { string }
+                            GlobalAsmOperandRef::Interpolate { string }
                         }
                         Err(ErrorHandled::Reported { .. }) => {
                             // An error has already been reported and
                             // compilation is guaranteed to fail if execution
                             // hits this path. So an empty string instead of
                             // a stringified constant value will suffice.
-                            GlobalAsmOperandRef::Const { string: String::new() }
+                            GlobalAsmOperandRef::Interpolate { string: String::new() }
                         }
                         Err(ErrorHandled::TooGeneric(_)) => {
                             span_bug!(*op_sp, "asm const cannot be resolved; too generic")

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1237,7 +1237,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         const_value,
                         bx.layout_of(value.ty()),
                     );
-                    InlineAsmOperandRef::Const { string }
+                    InlineAsmOperandRef::Interpolate { string }
                 }
                 mir::InlineAsmOperand::SymFn { ref value } => {
                     let const_ = self.monomorphize(value.const_);

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -85,7 +85,7 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
                 cx.layout_of(mono_type),
             );
 
-            GlobalAsmOperandRef::Const { string }
+            GlobalAsmOperandRef::Interpolate { string }
         }
         InlineAsmOperand::SymFn { value } => {
             let mono_type = instance.instantiate_mir_and_normalize_erasing_regions(

compiler/rustc_codegen_ssa/src/traits/asm.rs

@@ -25,7 +25,7 @@ pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
         in_value: OperandRef<'tcx, B::Value>,
         out_place: Option<PlaceRef<'tcx, B::Value>>,
     },
-    Const {
+    Interpolate {
         string: String,
     },
     SymFn {
@@ -41,7 +41,7 @@ pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
 
 #[derive(Debug)]
 pub enum GlobalAsmOperandRef<'tcx> {
-    Const { string: String },
+    Interpolate { string: String },
     SymFn { instance: Instance<'tcx> },
     SymStatic { def_id: DefId },
 }