lib/Target/Hexagon/HexagonMCInstLower.cpp

   1 //===- HexagonMCInstLower.cpp - Convert Hexagon MachineInstr to an MCInst -===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains code to lower Hexagon MachineInstrs to their corresponding
  11 // MCInst records.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "Hexagon.h"
  16 #include "HexagonAsmPrinter.h"
  17 #include "HexagonMachineFunctionInfo.h"
  18 #include "MCTargetDesc/HexagonMCInstrInfo.h"
  19
  20 #include "llvm/CodeGen/MachineBasicBlock.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/Mangler.h"
  23 #include "llvm/MC/MCContext.h"
  24 #include "llvm/MC/MCExpr.h"
  25 #include "llvm/MC/MCInst.h"
  26
  27 using namespace llvm;
  28
  29 static MCOperand GetSymbolRef(const MachineOperand& MO, const MCSymbol* Symbol,
  30                               HexagonAsmPrinter& Printer) {
  31   MCContext &MC = Printer.OutContext;
  32   const MCExpr *ME;
  33
  34   ME = MCSymbolRefExpr::create(Symbol, MCSymbolRefExpr::VK_None, MC);
  35
  36   if (!MO.isJTI() && MO.getOffset())
  37     ME = MCBinaryExpr::createAdd(ME, MCConstantExpr::create(MO.getOffset(), MC),
  38                                  MC);
  39
  40   return (MCOperand::createExpr(ME));
  41 }
  42
  43 // Create an MCInst from a MachineInstr
  44 void llvm::HexagonLowerToMC(MachineInstr const* MI, MCInst& MCB,
  45                             HexagonAsmPrinter& AP) {
  46   if(MI->getOpcode() == Hexagon::ENDLOOP0){
  47     HexagonMCInstrInfo::setInnerLoop(MCB);
  48     return;
  49   }
  50   if(MI->getOpcode() == Hexagon::ENDLOOP1){
  51     HexagonMCInstrInfo::setOuterLoop(MCB);
  52     return;
  53   }
  54   MCInst* MCI = new (AP.OutContext) MCInst;
  55   MCI->setOpcode(MI->getOpcode());
  56   assert(MCI->getOpcode() == static_cast<unsigned>(MI->getOpcode()) &&
  57          "MCI opcode should have been set on construction");
  58
  59   for (unsigned i = 0, e = MI->getNumOperands(); i < e; i++) {
  60     const MachineOperand &MO = MI->getOperand(i);
  61     MCOperand MCO;
  62
  63     switch (MO.getType()) {
  64     default:
  65       MI->dump();
  66       llvm_unreachable("unknown operand type");
  67     case MachineOperand::MO_Register:
  68       // Ignore all implicit register operands.
  69       if (MO.isImplicit()) continue;
  70       MCO = MCOperand::createReg(MO.getReg());
  71       break;
  72     case MachineOperand::MO_FPImmediate: {
  73       APFloat Val = MO.getFPImm()->getValueAPF();
  74       // FP immediates are used only when setting GPRs, so they may be dealt
  75       // with like regular immediates from this point on.
  76       MCO = MCOperand::createImm(*Val.bitcastToAPInt().getRawData());
  77       break;
  78     }
  79     case MachineOperand::MO_Immediate:
  80       MCO = MCOperand::createImm(MO.getImm());
  81       break;
  82     case MachineOperand::MO_MachineBasicBlock:
  83       MCO = MCOperand::createExpr
  84               (MCSymbolRefExpr::create(MO.getMBB()->getSymbol(),
  85                AP.OutContext));
  86       break;
  87     case MachineOperand::MO_GlobalAddress:
  88       MCO = GetSymbolRef(MO, AP.getSymbol(MO.getGlobal()), AP);
  89       break;
  90     case MachineOperand::MO_ExternalSymbol:
  91       MCO = GetSymbolRef(MO, AP.GetExternalSymbolSymbol(MO.getSymbolName()),
  92                          AP);
  93       break;
  94     case MachineOperand::MO_JumpTableIndex:
  95       MCO = GetSymbolRef(MO, AP.GetJTISymbol(MO.getIndex()), AP);
  96       break;
  97     case MachineOperand::MO_ConstantPoolIndex:
  98       MCO = GetSymbolRef(MO, AP.GetCPISymbol(MO.getIndex()), AP);
  99       break;
 100     case MachineOperand::MO_BlockAddress:
 101       MCO = GetSymbolRef(MO, AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP);
 102       break;
 103     }
 104
 105     MCI->addOperand(MCO);
 106   }
 107   MCB.addOperand(MCOperand::createInst(MCI));
 108 }