Add InlineAsmOperandRef::Const

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

Author: nbdd0121

compiler/rustc_codegen_gcc/src/asm.rs

@@ -276,6 +276,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("i"),
+                        rust_idx,
+                        val: value.immediate(),
+                    });
+                }
+
                 InlineAsmOperandRef::SymFn { instance } => {
                     // TODO(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O)
@@ -391,6 +399,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
                 }
@@ -464,6 +476,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

@@ -158,6 +158,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("i".to_string());
+                }
                 InlineAsmOperandRef::SymFn { instance } => {
                     inputs.push(self.cx.get_fn(instance));
                     op_idx.insert(idx, constraints.len());
@@ -205,6 +210,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

@@ -28,6 +28,9 @@ pub enum InlineAsmOperandRef<'tcx, B: BackendTypes + ?Sized> {
     Interpolate {
         string: String,
     },
+    Const {
+        value: OperandRef<'tcx, B::Value>,
+    },
     SymFn {
         instance: Instance<'tcx>,
     },