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