[GlobalISel] Introduce a G_DYN_STACKALLOC opcode to represent dynamic allocas

[aemerson]

Summary

This just adds the opcode and verifier, it will be used to replace existing dynamic alloca handling in a subsequent patch.

[paquette]

LGTM

[arsenm]

llvm/include/llvm/Target/GenericOpcodes.td

195

Should this be considered a side effect?

llvm/test/MachineVerifier/test_g_dyn_stackalloc.mir

2

REQUIRES: global-isel isn't necessary anymore

[aemerson]

llvm/include/llvm/Target/GenericOpcodes.td

195

I don't think so? G_FRAME_INDEX doesn't have side effects, so I don't think this should be counted as having it either. I do intend to use this to implement stack checking calls but that's a target dependent thing.

llvm/test/MachineVerifier/test_g_dyn_stackalloc.mir

2

Ok.

[arsenm]

llvm/include/llvm/Target/GenericOpcodes.td

195

The DAG equivalent has a chain. I think you could observe different behavior if you reordered a small and a large request

[aemerson]

llvm/include/llvm/Target/GenericOpcodes.td

195

That's true. I'll change it.

llvm/include/llvm/Support/TargetOpcodes.def

 HANDLE_TARGET_OPCODE(G_ADDRSPACE_CAST)
 
 /// Generic block address
 HANDLE_TARGET_OPCODE(G_BLOCK_ADDR)
 
 /// Generic jump table address
 HANDLE_TARGET_OPCODE(G_JUMP_TABLE)
 
+/// Generic dynamic stack allocation.
+HANDLE_TARGET_OPCODE(G_DYN_STACKALLOC)
+
 // TODO: Add more generic opcodes as we move along.
 
 /// Marker for the end of the generic opcode.
 /// This is used to check if an opcode is in the range of the
 /// generic opcodes.
-HANDLE_TARGET_OPCODE_MARKER(PRE_ISEL_GENERIC_OPCODE_END, G_JUMP_TABLE)
+HANDLE_TARGET_OPCODE_MARKER(PRE_ISEL_GENERIC_OPCODE_END, G_DYN_STACKALLOC)
 
 /// BUILTIN_OP_END - This must be the last enum value in this list.
 /// The target-specific post-isel opcode values start here.
 HANDLE_TARGET_OPCODE_MARKER(GENERIC_OP_END, PRE_ISEL_GENERIC_OPCODE_END)

llvm/include/llvm/Target/GenericOpcodes.td

 }
 
 def G_JUMP_TABLE : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins unknown:$jti);
   let hasSideEffects = 0;
 }
 
+def G_DYN_STACKALLOC : GenericInstruction {
+  let OutOperandList = (outs ptype0:$dst);
+  let InOperandList = (ins type1:$size, i32imm:$align);
+  let hasSideEffects = 0;
+}
+
 //------------------------------------------------------------------------------
 // Binary ops.
 //------------------------------------------------------------------------------
 
 // Generic addition.
 def G_ADD : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src1, type0:$src2);

llvm/lib/CodeGen/MachineVerifier.cpp

for (int Idx : MaskIdxes) {
         continue;
 
       if (Idx >= 2 * SrcNumElts)
         report("Out of bounds shuffle index", MI);
     }
 
     break;
   }
+  case TargetOpcode::G_DYN_STACKALLOC: {
+    const MachineOperand &DstOp = MI->getOperand(0);
+    const MachineOperand &AllocOp = MI->getOperand(1);
+    const MachineOperand &AlignOp = MI->getOperand(2);
+
+    if (!DstOp.isReg() || !MRI->getType(DstOp.getReg()).isPointer()) {
+      report("dst operand 0 must be a pointer type", MI);
+      break;
+    }
+
+    if (!AllocOp.isReg() || !MRI->getType(AllocOp.getReg()).isScalar()) {
+      report("src operand 1 must be a scalar reg type", MI);
+      break;
+    }
+
+    if (!AlignOp.isImm()) {
+      report("src operand 2 must be an immediate type", MI);
+      break;
+    }
+    break;
+  }
   default:
     break;
   }
 }
 
 void MachineVerifier::visitMachineInstrBefore(const MachineInstr *MI) {
   const MCInstrDesc &MCID = MI->getDesc();
   if (MI->getNumOperands() < MCID.getNumOperands()) {

llvm/test/MachineVerifier/test_g_dyn_stackalloc.mir

+# RUN: not llc -march=aarch64 -o /dev/null -run-pass=none -verify-machineinstrs %s 2>&1 | FileCheck %s
+# REQUIRES: global-isel, aarch64-registered-target
+
+---
+name:            test_dyn_stackalloc
+legalized:       true
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x0
+    %0:_(s64) = COPY $x0
+    %1:_(p0) = COPY $x0
+    ; CHECK: Bad machine code: Too few operands
+    G_DYN_STACKALLOC
+
+    ; CHECK: dst operand 0 must be a pointer type
+    %3:_(s64) = G_DYN_STACKALLOC %0, 4
+
+    ; CHECK: src operand 1 must be a scalar reg type
+    %4:_(p0) = G_DYN_STACKALLOC 0, 4
+
+    ; CHECK: src operand 2 must be an immediate type
+    %5:_(p0) = G_DYN_STACKALLOC %0, %0
+
+...