contrib/llvm/lib/Target/Hexagon/InstPrinter/HexagonInstPrinter.cpp

   1 //===- HexagonInstPrinter.cpp - Convert Hexagon MCInst to assembly syntax -===//
   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 class prints an Hexagon MCInst to a .s file.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "asm-printer"
  15 #include "HexagonAsmPrinter.h"
  16 #include "Hexagon.h"
  17 #include "HexagonInstPrinter.h"
  18 #include "MCTargetDesc/HexagonMCInst.h"
  19 #include "llvm/MC/MCInst.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/MC/MCAsmInfo.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <cstdio>
  25
  26 using namespace llvm;
  27
  28 #define GET_INSTRUCTION_NAME
  29 #include "HexagonGenAsmWriter.inc"
  30
  31 const char HexagonInstPrinter::PacketPadding = '\t';
  32
  33 StringRef HexagonInstPrinter::getOpcodeName(unsigned Opcode) const {
  34   return MII.getName(Opcode);
  35 }
  36
  37 StringRef HexagonInstPrinter::getRegName(unsigned RegNo) const {
  38   return getRegisterName(RegNo);
  39 }
  40
  41 void HexagonInstPrinter::printInst(const MCInst *MI, raw_ostream &O,
  42                                    StringRef Annot) {
  43   printInst((const HexagonMCInst*)(MI), O, Annot);
  44 }
  45
  46 void HexagonInstPrinter::printInst(const HexagonMCInst *MI, raw_ostream &O,
  47                                    StringRef Annot) {
  48   const char startPacket = '{',
  49              endPacket = '}';
  50   // TODO: add outer HW loop when it's supported too.
  51   if (MI->getOpcode() == Hexagon::ENDLOOP0) {
  52     // Ending a harware loop is different from ending an regular packet.
  53     assert(MI->isPacketEnd() && "Loop-end must also end the packet");
  54
  55     if (MI->isPacketStart()) {
  56       // There must be a packet to end a loop.
  57       // FIXME: when shuffling is always run, this shouldn't be needed.
  58       HexagonMCInst Nop;
  59       StringRef NoAnnot;
  60
  61       Nop.setOpcode (Hexagon::NOP);
  62       Nop.setPacketStart (MI->isPacketStart());
  63       printInst (&Nop, O, NoAnnot);
  64     }
  65
  66     // Close the packet.
  67     if (MI->isPacketEnd())
  68       O << PacketPadding << endPacket;
  69
  70     printInstruction(MI, O);
  71   }
  72   else {
  73     // Prefix the insn opening the packet.
  74     if (MI->isPacketStart())
  75       O << PacketPadding << startPacket << '\n';
  76
  77     printInstruction(MI, O);
  78
  79     // Suffix the insn closing the packet.
  80     if (MI->isPacketEnd())
  81       // Suffix the packet in a new line always, since the GNU assembler has
  82       // issues with a closing brace on the same line as CONST{32,64}.
  83       O << '\n' << PacketPadding << endPacket;
  84   }
  85
  86   printAnnotation(O, Annot);
  87 }
  88
  89 void HexagonInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
  90                                       raw_ostream &O) const {
  91   const MCOperand& MO = MI->getOperand(OpNo);
  92
  93   if (MO.isReg()) {
  94     O << getRegisterName(MO.getReg());
  95   } else if(MO.isExpr()) {
  96     O << *MO.getExpr();
  97   } else if(MO.isImm()) {
  98     printImmOperand(MI, OpNo, O);
  99   } else {
 100     llvm_unreachable("Unknown operand");
 101   }
 102 }
 103
 104 void HexagonInstPrinter::printImmOperand(const MCInst *MI, unsigned OpNo,
 105                                          raw_ostream &O) const {
 106   const MCOperand& MO = MI->getOperand(OpNo);
 107
 108   if(MO.isExpr()) {
 109     O << *MO.getExpr();
 110   } else if(MO.isImm()) {
 111     O << MI->getOperand(OpNo).getImm();
 112   } else {
 113     llvm_unreachable("Unknown operand");
 114   }
 115 }
 116
 117 void HexagonInstPrinter::printExtOperand(const MCInst *MI, unsigned OpNo,
 118                                          raw_ostream &O) const {
 119   const HexagonMCInst *HMCI = static_cast<const HexagonMCInst*>(MI);
 120   if (HMCI->isConstExtended())
 121     O << "#";
 122   printOperand(MI, OpNo, O);
 123 }
 124
 125 void HexagonInstPrinter::printUnsignedImmOperand(const MCInst *MI,
 126                                     unsigned OpNo, raw_ostream &O) const {
 127   O << MI->getOperand(OpNo).getImm();
 128 }
 129
 130 void HexagonInstPrinter::printNegImmOperand(const MCInst *MI, unsigned OpNo,
 131                                             raw_ostream &O) const {
 132   O << -MI->getOperand(OpNo).getImm();
 133 }
 134
 135 void HexagonInstPrinter::printNOneImmOperand(const MCInst *MI, unsigned OpNo,
 136                                              raw_ostream &O) const {
 137   O << -1;
 138 }
 139
 140 void HexagonInstPrinter::printMEMriOperand(const MCInst *MI, unsigned OpNo,
 141                                            raw_ostream &O) const {
 142   const MCOperand& MO0 = MI->getOperand(OpNo);
 143   const MCOperand& MO1 = MI->getOperand(OpNo + 1);
 144
 145   O << getRegisterName(MO0.getReg());
 146   O << " + #" << MO1.getImm();
 147 }
 148
 149 void HexagonInstPrinter::printFrameIndexOperand(const MCInst *MI, unsigned OpNo,
 150                                                 raw_ostream &O) const {
 151   const MCOperand& MO0 = MI->getOperand(OpNo);
 152   const MCOperand& MO1 = MI->getOperand(OpNo + 1);
 153
 154   O << getRegisterName(MO0.getReg()) << ", #" << MO1.getImm();
 155 }
 156
 157 void HexagonInstPrinter::printGlobalOperand(const MCInst *MI, unsigned OpNo,
 158                                             raw_ostream &O) const {
 159   assert(MI->getOperand(OpNo).isExpr() && "Expecting expression");
 160
 161   printOperand(MI, OpNo, O);
 162 }
 163
 164 void HexagonInstPrinter::printJumpTable(const MCInst *MI, unsigned OpNo,
 165                                         raw_ostream &O) const {
 166   assert(MI->getOperand(OpNo).isExpr() && "Expecting expression");
 167
 168   printOperand(MI, OpNo, O);
 169 }
 170
 171 void HexagonInstPrinter::printConstantPool(const MCInst *MI, unsigned OpNo,
 172                                            raw_ostream &O) const {
 173   assert(MI->getOperand(OpNo).isExpr() && "Expecting expression");
 174
 175   printOperand(MI, OpNo, O);
 176 }
 177
 178 void HexagonInstPrinter::printBranchOperand(const MCInst *MI, unsigned OpNo,
 179                                             raw_ostream &O) const {
 180   // Branches can take an immediate operand.  This is used by the branch
 181   // selection pass to print $+8, an eight byte displacement from the PC.
 182   assert("Unknown branch operand.");
 183 }
 184
 185 void HexagonInstPrinter::printCallOperand(const MCInst *MI, unsigned OpNo,
 186                                           raw_ostream &O) const {
 187 }
 188
 189 void HexagonInstPrinter::printAbsAddrOperand(const MCInst *MI, unsigned OpNo,
 190                                              raw_ostream &O) const {
 191 }
 192
 193 void HexagonInstPrinter::printPredicateOperand(const MCInst *MI, unsigned OpNo,
 194                                                raw_ostream &O) const {
 195 }
 196
 197 void HexagonInstPrinter::printSymbol(const MCInst *MI, unsigned OpNo,
 198                                      raw_ostream &O, bool hi) const {
 199   const MCOperand& MO = MI->getOperand(OpNo);
 200
 201   O << '#' << (hi? "HI": "LO") << '(';
 202   if (MO.isImm()) {
 203     O << '#';
 204     printOperand(MI, OpNo, O);
 205   } else {
 206     assert("Unknown symbol operand");
 207     printOperand(MI, OpNo, O);
 208   }
 209   O << ')';
 210 }