lib/CodeGen/MachineInstrAnnot.cpp

   1 //===-- MachineInstrAnnot.cpp ---------------------------------------------===//
   2 //
   3 //  This file defines Annotations used to pass information between code
   4 //  generation phases.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "llvm/CodeGen/MachineInstrAnnot.h"
   9 #include "llvm/CodeGen/InstrSelection.h"
  10 #include "llvm/CodeGen/InstrSelectionSupport.h"
  11 #include "llvm/CodeGen/MachineCodeForInstruction.h"
  12 #include "llvm/iOther.h"
  13 #include "llvm/Type.h"
  14
  15
  16 CallArgsDescriptor::CallArgsDescriptor(const CallInst* _callInstr,
  17                                        TmpInstruction* _retAddrReg,
  18                                        bool _isVarArgs, bool _noPrototype)
  19   : callInstr(_callInstr),
  20     funcPtr(isa<Function>(_callInstr->getCalledValue())
  21             ? NULL : _callInstr->getCalledValue()),
  22     retAddrReg(_retAddrReg),
  23     isVarArgs(_isVarArgs),
  24     noPrototype(_noPrototype)
  25 {
  26   unsigned int numArgs = callInstr->getNumOperands();
  27   argInfoVec.reserve(numArgs);
  28   assert(callInstr->getOperand(0) == callInstr->getCalledValue()
  29          && "Operand 0 is ignored in the loop below!");
  30   for (unsigned int i=1; i < numArgs; ++i)
  31     argInfoVec.push_back(CallArgInfo(callInstr->getOperand(i)));
  32
  33   // Enter this object in the MachineCodeForInstr object of the CallInst.
  34   // This transfers ownership of this object.
  35   MachineCodeForInstruction::get(callInstr).setCallArgsDescriptor(this);
  36 }
  37
  38
  39 const CallInst*
  40 CallArgsDescriptor::getReturnValue() const
  41 {
  42   return (callInstr->getType() == Type::VoidTy? NULL : callInstr);
  43 }
  44
  45
  46 // Mechanism to get the descriptor for a CALL MachineInstr.
  47 // We get the LLVM CallInstr from the ret. addr. register argument
  48 // of the CALL MachineInstr (which is explicit operand #3 for indirect
  49 // calls or the last implicit operand for direct calls).  We then get
  50 // the CallArgsDescriptor from the MachineCodeForInstruction object for
  51 // the CallInstr.
  52 // This is roundabout but avoids adding a new map or annotation just
  53 // to keep track of CallArgsDescriptors.
  54 //
  55 CallArgsDescriptor *CallArgsDescriptor::get(const MachineInstr* MI)
  56 {
  57   const TmpInstruction* retAddrReg =
  58     cast<TmpInstruction>(isa<Function>(MI->getOperand(0).getVRegValue())
  59                          ? MI->getImplicitRef(MI->getNumImplicitRefs()-1)
  60                          : MI->getOperand(2).getVRegValue());
  61
  62   assert(retAddrReg->getNumOperands() == 1 &&
  63          isa<CallInst>(retAddrReg->getOperand(0)) &&
  64          "Location of callInstr arg for CALL instr. changed? FIX THIS CODE!");
  65
  66   const CallInst* callInstr = cast<CallInst>(retAddrReg->getOperand(0));
  67
  68   CallArgsDescriptor* desc =
  69     MachineCodeForInstruction::get(callInstr).getCallArgsDescriptor();
  70   assert(desc->getCallInst()==callInstr && "Incorrect call args descriptor?");
  71   return desc;
  72 }