/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/Target/Lanai/LanaiMCInstLower.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //=-- LanaiMCInstLower.cpp - Convert Lanai 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 Lanai MachineInstrs to their corresponding |
11 | | // MCInst records. |
12 | | // |
13 | | //===----------------------------------------------------------------------===// |
14 | | |
15 | | #include "LanaiMCInstLower.h" |
16 | | |
17 | | #include "MCTargetDesc/LanaiBaseInfo.h" |
18 | | #include "MCTargetDesc/LanaiMCExpr.h" |
19 | | #include "llvm/ADT/SmallString.h" |
20 | | #include "llvm/CodeGen/AsmPrinter.h" |
21 | | #include "llvm/CodeGen/MachineBasicBlock.h" |
22 | | #include "llvm/CodeGen/MachineInstr.h" |
23 | | #include "llvm/IR/Constants.h" |
24 | | #include "llvm/MC/MCAsmInfo.h" |
25 | | #include "llvm/MC/MCContext.h" |
26 | | #include "llvm/MC/MCExpr.h" |
27 | | #include "llvm/MC/MCInst.h" |
28 | | #include "llvm/Support/ErrorHandling.h" |
29 | | #include "llvm/Support/raw_ostream.h" |
30 | | |
31 | | using namespace llvm; |
32 | | |
33 | | MCSymbol * |
34 | 22 | LanaiMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const { |
35 | 22 | return Printer.getSymbol(MO.getGlobal()); |
36 | 22 | } |
37 | | |
38 | | MCSymbol * |
39 | 0 | LanaiMCInstLower::GetBlockAddressSymbol(const MachineOperand &MO) const { |
40 | 0 | return Printer.GetBlockAddressSymbol(MO.getBlockAddress()); |
41 | 0 | } |
42 | | |
43 | | MCSymbol * |
44 | 7 | LanaiMCInstLower::GetExternalSymbolSymbol(const MachineOperand &MO) const { |
45 | 7 | return Printer.GetExternalSymbolSymbol(MO.getSymbolName()); |
46 | 7 | } |
47 | | |
48 | 0 | MCSymbol *LanaiMCInstLower::GetJumpTableSymbol(const MachineOperand &MO) const { |
49 | 0 | SmallString<256> Name; |
50 | 0 | raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "JTI" |
51 | 0 | << Printer.getFunctionNumber() << '_' |
52 | 0 | << MO.getIndex(); |
53 | 0 | // Create a symbol for the name. |
54 | 0 | return Ctx.getOrCreateSymbol(Name.str()); |
55 | 0 | } |
56 | | |
57 | | MCSymbol * |
58 | 0 | LanaiMCInstLower::GetConstantPoolIndexSymbol(const MachineOperand &MO) const { |
59 | 0 | SmallString<256> Name; |
60 | 0 | raw_svector_ostream(Name) << Printer.MAI->getPrivateGlobalPrefix() << "CPI" |
61 | 0 | << Printer.getFunctionNumber() << '_' |
62 | 0 | << MO.getIndex(); |
63 | 0 | // Create a symbol for the name. |
64 | 0 | return Ctx.getOrCreateSymbol(Name.str()); |
65 | 0 | } |
66 | | |
67 | | MCOperand LanaiMCInstLower::LowerSymbolOperand(const MachineOperand &MO, |
68 | 29 | MCSymbol *Sym) const { |
69 | 29 | LanaiMCExpr::VariantKind Kind; |
70 | 29 | |
71 | 29 | switch (MO.getTargetFlags()) { |
72 | 15 | case LanaiII::MO_NO_FLAG: |
73 | 15 | Kind = LanaiMCExpr::VK_Lanai_None; |
74 | 15 | break; |
75 | 7 | case LanaiII::MO_ABS_HI: |
76 | 7 | Kind = LanaiMCExpr::VK_Lanai_ABS_HI; |
77 | 7 | break; |
78 | 7 | case LanaiII::MO_ABS_LO: |
79 | 7 | Kind = LanaiMCExpr::VK_Lanai_ABS_LO; |
80 | 7 | break; |
81 | 0 | default: |
82 | 0 | llvm_unreachable("Unknown target flag on GV operand"); |
83 | 29 | } |
84 | 29 | |
85 | 29 | const MCExpr *Expr = |
86 | 29 | MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx); |
87 | 29 | if (!MO.isJTI() && 29 MO.getOffset()29 ) |
88 | 0 | Expr = MCBinaryExpr::createAdd( |
89 | 0 | Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx); |
90 | 29 | Expr = LanaiMCExpr::create(Kind, Expr, Ctx); |
91 | 29 | return MCOperand::createExpr(Expr); |
92 | 29 | } |
93 | | |
94 | 871 | void LanaiMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const { |
95 | 871 | OutMI.setOpcode(MI->getOpcode()); |
96 | 871 | |
97 | 3.77k | for (unsigned I = 0, E = MI->getNumOperands(); I != E3.77k ; ++I2.90k ) { |
98 | 2.90k | const MachineOperand &MO = MI->getOperand(I); |
99 | 2.90k | |
100 | 2.90k | MCOperand MCOp; |
101 | 2.90k | switch (MO.getType()) { |
102 | 1.87k | case MachineOperand::MO_Register: |
103 | 1.87k | // Ignore all implicit register operands. |
104 | 1.87k | if (MO.isImplicit()) |
105 | 373 | continue; |
106 | 1.50k | MCOp = MCOperand::createReg(MO.getReg()); |
107 | 1.50k | break; |
108 | 969 | case MachineOperand::MO_Immediate: |
109 | 969 | MCOp = MCOperand::createImm(MO.getImm()); |
110 | 969 | break; |
111 | 20 | case MachineOperand::MO_MachineBasicBlock: |
112 | 20 | MCOp = MCOperand::createExpr( |
113 | 20 | MCSymbolRefExpr::create(MO.getMBB()->getSymbol(), Ctx)); |
114 | 20 | break; |
115 | 13 | case MachineOperand::MO_RegisterMask: |
116 | 13 | continue; |
117 | 22 | case MachineOperand::MO_GlobalAddress: |
118 | 22 | MCOp = LowerSymbolOperand(MO, GetGlobalAddressSymbol(MO)); |
119 | 22 | break; |
120 | 0 | case MachineOperand::MO_BlockAddress: |
121 | 0 | MCOp = LowerSymbolOperand(MO, GetBlockAddressSymbol(MO)); |
122 | 0 | break; |
123 | 7 | case MachineOperand::MO_ExternalSymbol: |
124 | 7 | MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO)); |
125 | 7 | break; |
126 | 0 | case MachineOperand::MO_JumpTableIndex: |
127 | 0 | MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO)); |
128 | 0 | break; |
129 | 0 | case MachineOperand::MO_ConstantPoolIndex: |
130 | 0 | MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO)); |
131 | 0 | break; |
132 | 0 | default: |
133 | 0 | MI->print(errs()); |
134 | 0 | llvm_unreachable("unknown operand type"); |
135 | 2.52k | } |
136 | 2.52k | |
137 | 2.52k | OutMI.addOperand(MCOp); |
138 | 2.52k | } |
139 | 871 | } |