← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to lib/Target/Hexagon/HexagonMCInstLower.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Target/Hexagon/HexagonMCInstLower.cpp
 
1
//===- HexagonMCInstLower.cpp - Convert Hexagon 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 Hexagon MachineInstrs to their corresponding
 
11
// MCInst records.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#include "Hexagon.h"
 
16
#include "HexagonAsmPrinter.h"
 
17
#include "HexagonMachineFunctionInfo.h"
 
18
#include "MCTargetDesc/HexagonMCInstrInfo.h"
 
19
 
 
20
#include "llvm/CodeGen/MachineBasicBlock.h"
 
21
#include "llvm/IR/Constants.h"
 
22
#include "llvm/IR/Mangler.h"
 
23
#include "llvm/MC/MCContext.h"
 
24
#include "llvm/MC/MCExpr.h"
 
25
#include "llvm/MC/MCInst.h"
 
26
 
 
27
using namespace llvm;
 
28
 
 
29
static MCOperand GetSymbolRef(const MachineOperand& MO, const MCSymbol* Symbol,
 
30
                              HexagonAsmPrinter& Printer) {
 
31
  MCContext &MC = Printer.OutContext;
 
32
  const MCExpr *ME;
 
33
 
 
34
  ME = MCSymbolRefExpr::create(Symbol, MCSymbolRefExpr::VK_None, MC);
 
35
 
 
36
  if (!MO.isJTI() && MO.getOffset())
 
37
    ME = MCBinaryExpr::createAdd(ME, MCConstantExpr::create(MO.getOffset(), MC),
 
38
                                 MC);
 
39
 
 
40
  return (MCOperand::createExpr(ME));
 
41
}
 
42
 
 
43
// Create an MCInst from a MachineInstr
 
44
void llvm::HexagonLowerToMC(MachineInstr const* MI, MCInst& MCB,
 
45
                            HexagonAsmPrinter& AP) {
 
46
  if(MI->getOpcode() == Hexagon::ENDLOOP0){
 
47
    HexagonMCInstrInfo::setInnerLoop(MCB);
 
48
    return;
 
49
  }
 
50
  if(MI->getOpcode() == Hexagon::ENDLOOP1){
 
51
    HexagonMCInstrInfo::setOuterLoop(MCB);
 
52
    return;
 
53
  }
 
54
  MCInst* MCI = new (AP.OutContext) MCInst;
 
55
  MCI->setOpcode(MI->getOpcode());
 
56
  assert(MCI->getOpcode() == static_cast<unsigned>(MI->getOpcode()) &&
 
57
         "MCI opcode should have been set on construction");
 
58
 
 
59
  for (unsigned i = 0, e = MI->getNumOperands(); i < e; i++) {
 
60
    const MachineOperand &MO = MI->getOperand(i);
 
61
    MCOperand MCO;
 
62
 
 
63
    switch (MO.getType()) {
 
64
    default:
 
65
      MI->dump();
 
66
      llvm_unreachable("unknown operand type");
 
67
    case MachineOperand::MO_Register:
 
68
      // Ignore all implicit register operands.
 
69
      if (MO.isImplicit()) continue;
 
70
      MCO = MCOperand::createReg(MO.getReg());
 
71
      break;
 
72
    case MachineOperand::MO_FPImmediate: {
 
73
      APFloat Val = MO.getFPImm()->getValueAPF();
 
74
      // FP immediates are used only when setting GPRs, so they may be dealt
 
75
      // with like regular immediates from this point on.
 
76
      MCO = MCOperand::createImm(*Val.bitcastToAPInt().getRawData());
 
77
      break;
 
78
    }
 
79
    case MachineOperand::MO_Immediate:
 
80
      MCO = MCOperand::createImm(MO.getImm());
 
81
      break;
 
82
    case MachineOperand::MO_MachineBasicBlock:
 
83
      MCO = MCOperand::createExpr
 
84
              (MCSymbolRefExpr::create(MO.getMBB()->getSymbol(),
 
85
               AP.OutContext));
 
86
      break;
 
87
    case MachineOperand::MO_GlobalAddress:
 
88
      MCO = GetSymbolRef(MO, AP.getSymbol(MO.getGlobal()), AP);
 
89
      break;
 
90
    case MachineOperand::MO_ExternalSymbol:
 
91
      MCO = GetSymbolRef(MO, AP.GetExternalSymbolSymbol(MO.getSymbolName()),
 
92
                         AP);
 
93
      break;
 
94
    case MachineOperand::MO_JumpTableIndex:
 
95
      MCO = GetSymbolRef(MO, AP.GetJTISymbol(MO.getIndex()), AP);
 
96
      break;
 
97
    case MachineOperand::MO_ConstantPoolIndex:
 
98
      MCO = GetSymbolRef(MO, AP.GetCPISymbol(MO.getIndex()), AP);
 
99
      break;
 
100
    case MachineOperand::MO_BlockAddress:
 
101
      MCO = GetSymbolRef(MO, AP.GetBlockAddressSymbol(MO.getBlockAddress()),AP);
 
102
      break;
 
103
    }
 
104
 
 
105
    MCI->addOperand(MCO);
 
106
  }
 
107
  MCB.addOperand(MCOperand::createInst(MCI));
 
108
}