Subzero: Assemble calls to constant addresses.

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the InstX8632 and OperandX8632 classes,
@@ skipping 471 matching lines @@
   } else if (const auto Mem = llvm::dyn_cast<OperandX8632Mem>(Target)) {
     (void)Mem;
     assert(Mem->getSegmentRegister() == OperandX8632Mem::DefaultSegment);
     llvm::report_fatal_error("Assembler can't jmp to memory operand");
   } else if (const auto CR = llvm::dyn_cast<ConstantRelocatable>(Target)) {
     assert(CR->getOffset() == 0 && "We only support jumping to a function");
     Asm->jmp(CR);
   } else if (const auto Imm = llvm::dyn_cast<ConstantInteger32>(Target)) {
     // NaCl trampoline calls refer to an address within the sandbox directly.
     // This is usually only needed for non-IRT builds and otherwise not
-    // very portable or stable. For this, we would use the 0xE8 opcode
-    // (relative version of call) and there should be a PC32 reloc too.
-    // The PC32 reloc will have symbol index 0, and the absolute address
-    // would be encoded as an offset relative to the next instruction.
-    // TODO(jvoung): Do we need to support this?
+    // very portable or stable. Usually this is only done for "calls"
+    // and not jumps.
+    // TODO(jvoung): Support this when there is a lowering that
+    // actually triggers this case.
     (void)Imm;
     llvm::report_fatal_error("Unexpected jmp to absolute address");
   } else {
     llvm::report_fatal_error("Unexpected operand type");
   }
 }
 
 void InstX8632Jmp::dump(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "jmp ";
   getJmpTarget()->dump(Func);
 }
 
 void InstX8632Call::emit(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   Str << "\tcall\t";
-  if (const auto CallTarget =
-          llvm::dyn_cast<ConstantRelocatable>(getCallTarget())) {
-    // TODO(stichnot): All constant targets should suppress the '$',
-    // not just relocatables.
+  if (const auto CallTarget = llvm::dyn_cast<Constant>(getCallTarget())) {
     CallTarget->emitWithoutDollar(Func->getContext());
   } else {
     Str << "*";
     getCallTarget()->emit(Func);
   }
   Func->getTarget()->resetStackAdjustment();
 }
 
 void InstX8632Call::emitIAS(const Cfg *Func) const {
   x86::AssemblerX86 *Asm = Func->getAssembler<x86::AssemblerX86>();
   Operand *Target = getCallTarget();
   if (const auto Var = llvm::dyn_cast<Variable>(Target)) {
     if (Var->hasReg()) {
       Asm->call(RegX8632::getEncodedGPR(Var->getRegNum()));
     } else {
       Asm->call(static_cast<TargetX8632 *>(Func->getTarget())
                     ->stackVarToAsmOperand(Var));
     }
   } else if (const auto Mem = llvm::dyn_cast<OperandX8632Mem>(Target)) {
     assert(Mem->getSegmentRegister() == OperandX8632Mem::DefaultSegment);
     Asm->call(Mem->toAsmAddress(Asm));
   } else if (const auto CR = llvm::dyn_cast<ConstantRelocatable>(Target)) {
     assert(CR->getOffset() == 0 && "We only support calling a function");
     Asm->call(CR);
   } else if (const auto Imm = llvm::dyn_cast<ConstantInteger32>(Target)) {
-    // NaCl trampoline calls refer to an address within the sandbox directly.
-    // This is usually only needed for non-IRT builds and otherwise not
-    // very portable or stable. For this, we would use the 0xE8 opcode
-    // (relative version of call) and there should be a PC32 reloc too.
-    // The PC32 reloc will have symbol index 0, and the absolute address
-    // would be encoded as an offset relative to the next instruction.
-    // TODO(jvoung): Do we need to support this?
-    (void)Imm;
-    llvm_unreachable("Unexpected call to absolute address");
+    Asm->call(x86::Immediate(Imm->getValue()));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
   Func->getTarget()->resetStackAdjustment();
 }
 
 void InstX8632Call::dump(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
@@ skipping 2370 matching lines @@
   }
   Str << "(";
   if (Func)
     Var->dump(Func);
   else
     Var->dump(Str);
   Str << ")";
 }
 
 } // end of namespace Ice