Coverage Report

Created: 2017-10-03 07:32

/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
}