lib/Target/MSP430/MSP430MCInstLower.cpp

   1 //===-- MSP430MCInstLower.cpp - Convert MSP430 MachineInstr to an MCInst --===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains code to lower MSP430 MachineInstrs to their corresponding
  10 // MCInst records.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MSP430MCInstLower.h"
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/CodeGen/AsmPrinter.h"
  17 #include "llvm/CodeGen/MachineBasicBlock.h"
  18 #include "llvm/CodeGen/MachineInstr.h"
  19 #include "llvm/IR/DataLayout.h"
  20 #include "llvm/IR/Mangler.h"
  21 #include "llvm/MC/MCAsmInfo.h"
  22 #include "llvm/MC/MCContext.h"
  23 #include "llvm/MC/MCExpr.h"
  24 #include "llvm/MC/MCInst.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include "llvm/Target/TargetMachine.h"
  28 using namespace llvm;
  29
  30 MCSymbol *MSP430MCInstLower::
  31 GetGlobalAddressSymbol(const MachineOperand &MO) const {
  32   switch (MO.getTargetFlags()) {
  33   default: llvm_unreachable("Unknown target flag on GV operand");
  34   case 0: break;
  35   }
  36
  37   return Printer.getSymbol(MO.getGlobal());
  38 }
  39
  40 MCSymbol *MSP430MCInstLower::
  41 GetExternalSymbolSymbol(const MachineOperand &MO) const {
  42   switch (MO.getTargetFlags()) {
  43   default: llvm_unreachable("Unknown target flag on GV operand");
  44   case 0: break;
  45   }
  46
  47   return Printer.GetExternalSymbolSymbol(MO.getSymbolName());
  48 }
  49
  50 MCSymbol *MSP430MCInstLower::
  51 GetJumpTableSymbol(const MachineOperand &MO) const {
  52   const DataLayout &DL = Printer.getDataLayout();
  53   SmallString<256> Name;
  54   raw_svector_ostream(Name) << DL.getPrivateGlobalPrefix() << "JTI"
  55                             << Printer.getFunctionNumber() << '_'
  56                             << MO.getIndex();
  57
  58   switch (MO.getTargetFlags()) {
  59   default: llvm_unreachable("Unknown target flag on GV operand");
  60   case 0: break;
  61   }
  62
  63   // Create a symbol for the name.
  64   return Ctx.getOrCreateSymbol(Name);
  65 }
  66
  67 MCSymbol *MSP430MCInstLower::
  68 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
  69   const DataLayout &DL = Printer.getDataLayout();
  70   SmallString<256> Name;
  71   raw_svector_ostream(Name) << DL.getPrivateGlobalPrefix() << "CPI"
  72                             << Printer.getFunctionNumber() << '_'
  73                             << MO.getIndex();
  74
  75   switch (MO.getTargetFlags()) {
  76   default: llvm_unreachable("Unknown target flag on GV operand");
  77   case 0: break;
  78   }
  79
  80   // Create a symbol for the name.
  81   return Ctx.getOrCreateSymbol(Name);
  82 }
  83
  84 MCSymbol *MSP430MCInstLower::
  85 GetBlockAddressSymbol(const MachineOperand &MO) const {
  86   switch (MO.getTargetFlags()) {
  87   default: llvm_unreachable("Unknown target flag on GV operand");
  88   case 0: break;
  89   }
  90
  91   return Printer.GetBlockAddressSymbol(MO.getBlockAddress());
  92 }
  93
  94 MCOperand MSP430MCInstLower::
  95 LowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const {
  96   // FIXME: We would like an efficient form for this, so we don't have to do a
  97   // lot of extra uniquing.
  98   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Ctx);
  99
 100   switch (MO.getTargetFlags()) {
 101   default: llvm_unreachable("Unknown target flag on GV operand");
 102   case 0: break;
 103   }
 104
 105   if (!MO.isJTI() && MO.getOffset())
 106     Expr = MCBinaryExpr::createAdd(Expr,
 107                                    MCConstantExpr::create(MO.getOffset(), Ctx),
 108                                    Ctx);
 109   return MCOperand::createExpr(Expr);
 110 }
 111
 112 #define GET_REGINFO_ENUM
 113 #include "MSP430GenRegisterInfo.inc"
 114
 115 void MSP430MCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 116   OutMI.setOpcode(MI->getOpcode());
 117
 118   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 119     const MachineOperand &MO = MI->getOperand(i);
 120
 121     MCOperand MCOp;
 122     switch (MO.getType()) {
 123     default:
 124       MI->print(errs());
 125       llvm_unreachable("unknown operand type");
 126     case MachineOperand::MO_Register:
 127       // Ignore all implicit register operands.
 128       if (MO.isImplicit()) continue;
 129       MCOp = MCOperand::createReg(MO.getReg());
 130       break;
 131     case MachineOperand::MO_Immediate:
 132       MCOp = MCOperand::createImm(MO.getImm());
 133       break;
 134     case MachineOperand::MO_MachineBasicBlock:
 135       MCOp = MCOperand::createExpr(MCSymbolRefExpr::create(
 136                          MO.getMBB()->getSymbol(), Ctx));
 137       break;
 138     case MachineOperand::MO_GlobalAddress:
 139       MCOp = LowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
 140       break;
 141     case MachineOperand::MO_ExternalSymbol:
 142       MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
 143       break;
 144     case MachineOperand::MO_JumpTableIndex:
 145       MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
 146       break;
 147     case MachineOperand::MO_ConstantPoolIndex:
 148       MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
 149       break;
 150     case MachineOperand::MO_BlockAddress:
 151       MCOp = LowerSymbolOperand(MO, GetBlockAddressSymbol(MO));
 152       break;
 153     case MachineOperand::MO_RegisterMask:
 154       continue;
 155     }
 156
 157     OutMI.addOperand(MCOp);
 158   }
 159 }