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

@@ -272,7 +272,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;
                 }
 
@@ -387,7 +387,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     });
                 }
 
-                InlineAsmOperandRef::Const { .. } => {
+                InlineAsmOperandRef::Interpolate { .. } => {
                     // processed in the previous pass
                 }
 
@@ -480,7 +480,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);
                         }
 
@@ -830,7 +830,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/mir/block.rs

@@ -1238,7 +1238,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

@@ -76,7 +76,7 @@ fn inline_to_global_operand<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 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/mono_item.rs

@@ -54,14 +54,14 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                                             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!(

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 },
 }