Add InlineAsmOperandRef::Const

This is intended for supporting passing arbitrary CTFE const into inline
assembly.

Author: nbdd0121

compiler/rustc_codegen_gcc/src/asm.rs

@@ -307,6 +307,14 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     constants_len += string.len() + att_dialect as usize;
                 }
 
+                InlineAsmOperandRef::Const { value } => {
+                    inputs.push(AsmInOperand {
+                        constraint: Cow::Borrowed("is"),
+                        rust_idx,
+                        val: value.immediate(),
+                    });
+                }
+
                 InlineAsmOperandRef::SymFn { instance } => {
                     // TODO(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O)
@@ -422,6 +430,10 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     // processed in the previous pass
                 }
 
+                InlineAsmOperandRef::Const { .. } => {
+                    // processed in the previous pass
+                }
+
                 InlineAsmOperandRef::Label { .. } => {
                     // processed in the previous pass
                 }
@@ -495,6 +507,15 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                             push_to_template(modifier, gcc_index);
                         }
 
+                        InlineAsmOperandRef::Const { .. } => {
+                            let in_gcc_index = inputs
+                                .iter()
+                                .position(|op| operand_idx == op.rust_idx)
+                                .expect("wrong rust index");
+                            let gcc_index = in_gcc_index + outputs.len();
+                            push_to_template(None, gcc_index);
+                        }
+
                         InlineAsmOperandRef::SymFn { instance } => {
                             // TODO(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)

compiler/rustc_codegen_llvm/src/asm.rs

@@ -157,6 +157,11 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         constraints.push(format!("{}", op_idx[&idx]));
                     }
                 }
+                InlineAsmOperandRef::Const { value } => {
+                    inputs.push(value.immediate());
+                    op_idx.insert(idx, constraints.len());
+                    constraints.push("is".to_string());
+                }
                 InlineAsmOperandRef::SymFn { instance } => {
                     inputs.push(self.cx.get_fn(instance));
                     op_idx.insert(idx, constraints.len());
@@ -204,6 +209,9 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                                 template_str.push_str(&format!("${{{}}}", op_idx[&operand_idx]));
                             }
                         }
+                        InlineAsmOperandRef::Const { .. } => {
+                            template_str.push_str(&format!("${{{}:c}}", op_idx[&operand_idx]));
+                        }
                         InlineAsmOperandRef::Interpolate { ref string } => {
                             // Const operands get injected directly into the template
                             template_str.push_str(string);

compiler/rustc_codegen_ssa/src/traits/asm.rs

@@ -25,9 +25,18 @@ pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
         in_value: OperandRef<'tcx, B::Value>,
         out_place: Option<PlaceRef<'tcx, B::Value>>,
     },
+    /// Interpolate a string directly into the inline assembly.
+    ///
+    /// This is distinct from `Const`, which can reference a const pointer or reference (and thus is
+    /// a const in Rust/linker sense but not a literal value).
+    ///
+    /// We currently use this for constant integers. They could technically use `Const` as well.
     Interpolate {
         string: String,
     },
+    Const {
+        value: OperandRef<'tcx, B::Value>,
+    },
     SymFn {
         instance: Instance<'tcx>,
     },