Coverage Report

Created: 2017-10-03 07:32

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