lib/Target/ARM/AsmPrinter/ARMInstPrinter.cpp

   1 //===-- ARMInstPrinter.cpp - Convert ARM 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 ARM MCInst to a .s file.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "asm-printer"
  15 #include "ARMInstPrinter.h"
  16 #include "ARMAddressingModes.h"
  17 #include "llvm/MC/MCInst.h"
  18 #include "llvm/MC/MCAsmInfo.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include "ARMGenInstrNames.inc"
  22 using namespace llvm;
  23
  24 // Include the auto-generated portion of the assembly writer.
  25 #define MachineInstr MCInst
  26 #define ARMAsmPrinter ARMInstPrinter  // FIXME: REMOVE.
  27 #define NO_ASM_WRITER_BOILERPLATE
  28 #include "ARMGenAsmWriter.inc"
  29 #undef MachineInstr
  30 #undef ARMAsmPrinter
  31
  32 void ARMInstPrinter::printInst(const MCInst *MI) { printInstruction(MI); }
  33
  34 void ARMInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
  35                                   const char *Modifier) {
  36   // FIXME: TURN ASSERT ON.
  37   //assert((Modifier == 0 || Modifier[0] == 0) && "Cannot print modifiers");
  38
  39   const MCOperand &Op = MI->getOperand(OpNo);
  40   if (Op.isReg()) {
  41     O << getRegisterName(Op.getReg());
  42   } else if (Op.isImm()) {
  43     O << '#' << Op.getImm();
  44   } else {
  45     assert(Op.isExpr() && "unknown operand kind in printOperand");
  46     Op.getExpr()->print(O, &MAI);
  47   }
  48 }
  49
  50 static void printSOImm(raw_ostream &O, int64_t V, bool VerboseAsm,
  51                        const MCAsmInfo *MAI) {
  52   // Break it up into two parts that make up a shifter immediate.
  53   V = ARM_AM::getSOImmVal(V);
  54   assert(V != -1 && "Not a valid so_imm value!");
  55
  56   unsigned Imm = ARM_AM::getSOImmValImm(V);
  57   unsigned Rot = ARM_AM::getSOImmValRot(V);
  58
  59   // Print low-level immediate formation info, per
  60   // A5.1.3: "Data-processing operands - Immediate".
  61   if (Rot) {
  62     O << "#" << Imm << ", " << Rot;
  63     // Pretty printed version.
  64     if (VerboseAsm)
  65       O << ' ' << MAI->getCommentString()
  66       << ' ' << (int)ARM_AM::rotr32(Imm, Rot);
  67   } else {
  68     O << "#" << Imm;
  69   }
  70 }
  71
  72
  73 /// printSOImmOperand - SOImm is 4-bit rotate amount in bits 8-11 with 8-bit
  74 /// immediate in bits 0-7.
  75 void ARMInstPrinter::printSOImmOperand(const MCInst *MI, unsigned OpNum) {
  76   const MCOperand &MO = MI->getOperand(OpNum);
  77   assert(MO.isImm() && "Not a valid so_imm value!");
  78   printSOImm(O, MO.getImm(), VerboseAsm, &MAI);
  79 }
  80
  81
  82
  83 void ARMInstPrinter::printAddrMode2Operand(const MCInst *MI, unsigned Op) {
  84   const MCOperand &MO1 = MI->getOperand(Op);
  85   const MCOperand &MO2 = MI->getOperand(Op+1);
  86   const MCOperand &MO3 = MI->getOperand(Op+2);
  87
  88   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
  89     printOperand(MI, Op);
  90     return;
  91   }
  92
  93   O << "[" << getRegisterName(MO1.getReg());
  94
  95   if (!MO2.getReg()) {
  96     if (ARM_AM::getAM2Offset(MO3.getImm()))  // Don't print +0.
  97       O << ", #"
  98       << (char)ARM_AM::getAM2Op(MO3.getImm())
  99       << ARM_AM::getAM2Offset(MO3.getImm());
 100     O << "]";
 101     return;
 102   }
 103
 104   O << ", "
 105   << (char)ARM_AM::getAM2Op(MO3.getImm())
 106   << getRegisterName(MO2.getReg());
 107
 108   if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm()))
 109     O << ", "
 110     << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm()))
 111     << " #" << ShImm;
 112   O << "]";
 113 }