1 //===-- XCoreMCInstLower.cpp - Convert XCore MachineInstr to 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 /// \file
11 /// \brief This file contains code to lower XCore MachineInstrs to their
12 /// corresponding MCInst records.
13 ///
14 //===----------------------------------------------------------------------===//
15 #include "XCoreMCInstLower.h"
16 #include "llvm/CodeGen/AsmPrinter.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/CodeGen/MachineInstr.h"
19 #include "llvm/CodeGen/MachineOperand.h"
20 #include "llvm/IR/Mangler.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCExpr.h"
23 #include "llvm/MC/MCInst.h"
24 
25 using namespace llvm;
26 
27 XCoreMCInstLower::XCoreMCInstLower(class AsmPrinter &asmprinter)
28     : Printer(asmprinter) {}
29 
30 void XCoreMCInstLower::Initialize(MCContext *C) { Ctx = C; }
31 
32 MCOperand XCoreMCInstLower::LowerSymbolOperand(const MachineOperand &MO,
33                                                MachineOperandType MOTy,
34                                                unsigned Offset) const {
35   MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
36   const MCSymbol *Symbol;
37 
38   switch (MOTy) {
39     case MachineOperand::MO_MachineBasicBlock:
40       Symbol = MO.getMBB()->getSymbol();
41       break;
42     case MachineOperand::MO_GlobalAddress:
43       Symbol = Printer.getSymbol(MO.getGlobal());
44       Offset += MO.getOffset();
45       break;
46     case MachineOperand::MO_BlockAddress:
47       Symbol = Printer.GetBlockAddressSymbol(MO.getBlockAddress());
48       Offset += MO.getOffset();
49       break;
50     case MachineOperand::MO_ExternalSymbol:
51       Symbol = Printer.GetExternalSymbolSymbol(MO.getSymbolName());
52       Offset += MO.getOffset();
53       break;
54     case MachineOperand::MO_JumpTableIndex:
55       Symbol = Printer.GetJTISymbol(MO.getIndex());
56       break;
57     case MachineOperand::MO_ConstantPoolIndex:
58       Symbol = Printer.GetCPISymbol(MO.getIndex());
59       Offset += MO.getOffset();
60       break;
61     default:
62       llvm_unreachable("<unknown operand type>");
63   }
64 
65   const MCSymbolRefExpr *MCSym = MCSymbolRefExpr::create(Symbol, Kind, *Ctx);
66 
67   if (!Offset)
68     return MCOperand::createExpr(MCSym);
69 
70   // Assume offset is never negative.
71   assert(Offset > 0);
72 
73   const MCConstantExpr *OffsetExpr =  MCConstantExpr::create(Offset, *Ctx);
74   const MCBinaryExpr *Add = MCBinaryExpr::createAdd(MCSym, OffsetExpr, *Ctx);
75   return MCOperand::createExpr(Add);
76 }
77 
78 MCOperand XCoreMCInstLower::LowerOperand(const MachineOperand &MO,
79                                          unsigned offset) const {
80   MachineOperandType MOTy = MO.getType();
81 
82   switch (MOTy) {
83     default: llvm_unreachable("unknown operand type");
84     case MachineOperand::MO_Register:
85       // Ignore all implicit register operands.
86       if (MO.isImplicit()) break;
87       return MCOperand::createReg(MO.getReg());
88     case MachineOperand::MO_Immediate:
89       return MCOperand::createImm(MO.getImm() + offset);
90     case MachineOperand::MO_MachineBasicBlock:
91     case MachineOperand::MO_GlobalAddress:
92     case MachineOperand::MO_ExternalSymbol:
93     case MachineOperand::MO_JumpTableIndex:
94     case MachineOperand::MO_ConstantPoolIndex:
95     case MachineOperand::MO_BlockAddress:
96       return LowerSymbolOperand(MO, MOTy, offset);
97     case MachineOperand::MO_RegisterMask:
98       break;
99   }
100 
101   return MCOperand();
102 }
103 
104 void XCoreMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
105   OutMI.setOpcode(MI->getOpcode());
106 
107   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
108     const MachineOperand &MO = MI->getOperand(i);
109     MCOperand MCOp = LowerOperand(MO);
110 
111     if (MCOp.isValid())
112       OutMI.addOperand(MCOp);
113   }
114 }
115