lib/Target/Alpha/AlphaAsmPrinter.cpp

   1 //===-- AlphaAsmPrinter.cpp - Alpha LLVM assembly writer ------------------===//
   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 a printer that converts from our internal representation
  11 // of machine-dependent LLVM code to GAS-format Alpha assembly language.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "asm-printer"
  16 #include "Alpha.h"
  17 #include "AlphaInstrInfo.h"
  18 #include "AlphaTargetMachine.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Type.h"
  21 #include "llvm/Assembly/Writer.h"
  22 #include "llvm/CodeGen/AsmPrinter.h"
  23 #include "llvm/Target/TargetAsmInfo.h"
  24 #include "llvm/Target/TargetMachine.h"
  25 #include "llvm/Support/Compiler.h"
  26 #include "llvm/Support/Mangler.h"
  27 #include "llvm/ADT/Statistic.h"
  28 using namespace llvm;
  29
  30 STATISTIC(EmittedInsts, "Number of machine instrs printed");
  31
  32 namespace {
  33   struct VISIBILITY_HIDDEN AlphaAsmPrinter : public AsmPrinter {
  34
  35     /// Unique incrementer for label values for referencing Global values.
  36     ///
  37
  38     AlphaAsmPrinter(std::ostream &o, TargetMachine &tm, const TargetAsmInfo *T)
  39       : AsmPrinter(o, tm, T) {
  40     }
  41
  42     virtual const char *getPassName() const {
  43       return "Alpha Assembly Printer";
  44     }
  45     bool printInstruction(const MachineInstr *MI);
  46     void printOp(const MachineOperand &MO, bool IsCallOp = false);
  47     void printOperand(const MachineInstr *MI, int opNum);
  48     void printBaseOffsetPair (const MachineInstr *MI, int i, bool brackets=true);
  49     bool runOnMachineFunction(MachineFunction &F);
  50     bool doInitialization(Module &M);
  51     bool doFinalization(Module &M);
  52
  53     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
  54                          unsigned AsmVariant, const char *ExtraCode);
  55     bool PrintAsmMemoryOperand(const MachineInstr *MI,
  56                                unsigned OpNo,
  57                                unsigned AsmVariant,
  58                                const char *ExtraCode);
  59   };
  60 } // end of anonymous namespace
  61
  62 /// createAlphaCodePrinterPass - Returns a pass that prints the Alpha
  63 /// assembly code for a MachineFunction to the given output stream,
  64 /// using the given target machine description.  This should work
  65 /// regardless of whether the function is in SSA form.
  66 ///
  67 FunctionPass *llvm::createAlphaCodePrinterPass(std::ostream &o,
  68                                                TargetMachine &tm) {
  69   return new AlphaAsmPrinter(o, tm, tm.getTargetAsmInfo());
  70 }
  71
  72 #include "AlphaGenAsmWriter.inc"
  73
  74 void AlphaAsmPrinter::printOperand(const MachineInstr *MI, int opNum)
  75 {
  76   const MachineOperand &MO = MI->getOperand(opNum);
  77   if (MO.getType() == MachineOperand::MO_Register) {
  78     assert(TargetRegisterInfo::isPhysicalRegister(MO.getReg()) &&
  79            "Not physreg??");
  80     O << TM.getRegisterInfo()->get(MO.getReg()).AsmName;
  81   } else if (MO.isImmediate()) {
  82     O << MO.getImm();
  83     assert(MO.getImm() < (1 << 30));
  84   } else {
  85     printOp(MO);
  86   }
  87 }
  88
  89
  90 void AlphaAsmPrinter::printOp(const MachineOperand &MO, bool IsCallOp) {
  91   const TargetRegisterInfo &RI = *TM.getRegisterInfo();
  92
  93   switch (MO.getType()) {
  94   case MachineOperand::MO_Register:
  95     O << RI.get(MO.getReg()).AsmName;
  96     return;
  97
  98   case MachineOperand::MO_Immediate:
  99     cerr << "printOp() does not handle immediate values\n";
 100     abort();
 101     return;
 102
 103   case MachineOperand::MO_MachineBasicBlock:
 104     printBasicBlockLabel(MO.getMBB());
 105     return;
 106
 107   case MachineOperand::MO_ConstantPoolIndex:
 108     O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
 109       << MO.getIndex();
 110     return;
 111
 112   case MachineOperand::MO_ExternalSymbol:
 113     O << MO.getSymbolName();
 114     return;
 115
 116   case MachineOperand::MO_GlobalAddress: {
 117     GlobalValue *GV = MO.getGlobal();
 118     O << Mang->getValueName(GV);
 119     if (GV->isDeclaration() && GV->hasExternalWeakLinkage())
 120       ExtWeakSymbols.insert(GV);
 121     return;
 122   }
 123
 124   case MachineOperand::MO_JumpTableIndex:
 125     O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 126       << '_' << MO.getIndex();
 127     return;
 128
 129   default:
 130     O << "<unknown operand type: " << MO.getType() << ">";
 131     return;
 132   }
 133 }
 134
 135 /// runOnMachineFunction - This uses the printMachineInstruction()
 136 /// method to print assembly for each instruction.
 137 ///
 138 bool AlphaAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 139   SetupMachineFunction(MF);
 140   O << "\n\n";
 141
 142   // Print out constants referenced by the function
 143   EmitConstantPool(MF.getConstantPool());
 144
 145   // Print out jump tables referenced by the function
 146   EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
 147
 148   // Print out labels for the function.
 149   const Function *F = MF.getFunction();
 150   SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
 151
 152   EmitAlignment(4, F);
 153   switch (F->getLinkage()) {
 154   default: assert(0 && "Unknown linkage type!");
 155   case Function::InternalLinkage:  // Symbols default to internal.
 156     break;
 157    case Function::ExternalLinkage:
 158      O << "\t.globl " << CurrentFnName << "\n";
 159      break;
 160   case Function::WeakLinkage:
 161   case Function::LinkOnceLinkage:
 162     O << TAI->getWeakRefDirective() << CurrentFnName << "\n";
 163     break;
 164   }
 165
 166   O << "\t.ent " << CurrentFnName << "\n";
 167
 168   O << CurrentFnName << ":\n";
 169
 170   // Print out code for the function.
 171   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 172        I != E; ++I) {
 173     if (I != MF.begin()) {
 174       printBasicBlockLabel(I, true, true);
 175       O << '\n';
 176     }
 177     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 178          II != E; ++II) {
 179       // Print the assembly for the instruction.
 180       ++EmittedInsts;
 181       if (!printInstruction(II)) {
 182         assert(0 && "Unhandled instruction in asm writer!");
 183         abort();
 184       }
 185     }
 186   }
 187
 188   O << "\t.end " << CurrentFnName << "\n";
 189
 190   // We didn't modify anything.
 191   return false;
 192 }
 193
 194 bool AlphaAsmPrinter::doInitialization(Module &M)
 195 {
 196   if(TM.getSubtarget<AlphaSubtarget>().hasCT())
 197     O << "\t.arch ev6\n"; //This might need to be ev67, so leave this test here
 198   else
 199     O << "\t.arch ev6\n";
 200   O << "\t.set noat\n";
 201   return AsmPrinter::doInitialization(M);
 202 }
 203
 204 bool AlphaAsmPrinter::doFinalization(Module &M) {
 205   const TargetData *TD = TM.getTargetData();
 206
 207   for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) {
 208
 209     if (!I->hasInitializer()) continue;  // External global require no code
 210
 211     // Check to see if this is a special global used by LLVM, if so, emit it.
 212     if (EmitSpecialLLVMGlobal(I))
 213       continue;
 214
 215     std::string name = Mang->getValueName(I);
 216     Constant *C = I->getInitializer();
 217     unsigned Size = TD->getABITypeSize(C->getType());
 218     unsigned Align = TD->getPreferredAlignmentLog(I);
 219
 220     //1: hidden?
 221     if (I->hasHiddenVisibility())
 222       O << TAI->getHiddenDirective() << name << "\n";
 223
 224     //2: kind
 225     switch (I->getLinkage()) {
 226     case GlobalValue::LinkOnceLinkage:
 227     case GlobalValue::WeakLinkage:
 228     case GlobalValue::CommonLinkage:
 229       O << TAI->getWeakRefDirective() << name << '\n';
 230       break;
 231     case GlobalValue::AppendingLinkage:
 232     case GlobalValue::ExternalLinkage:
 233       O << "\t.globl " << name << "\n";
 234       break;
 235     case GlobalValue::InternalLinkage:
 236       break;
 237     default:
 238       assert(0 && "Unknown linkage type!");
 239       cerr << "Unknown linkage type!\n";
 240       abort();
 241     }
 242
 243     //3: Section (if changed)
 244     if (I->hasSection() &&
 245         (I->getSection() == ".ctors" ||
 246          I->getSection() == ".dtors")) {
 247       std::string SectionName = ".section\t" + I->getSection()
 248         + ",\"aw\",@progbits";
 249       SwitchToDataSection(SectionName.c_str());
 250     } else {
 251       if (C->isNullValue())
 252         SwitchToDataSection("\t.section\t.bss", I);
 253       else
 254         SwitchToDataSection("\t.section\t.data", I);
 255     }
 256
 257     //4: Type, Size, Align
 258     O << "\t.type\t" << name << ", @object\n";
 259     O << "\t.size\t" << name << ", " << Size << "\n";
 260     EmitAlignment(Align, I);
 261
 262     O << name << ":\n";
 263
 264     // If the initializer is a extern weak symbol, remember to emit the weak
 265     // reference!
 266     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 267       if (GV->hasExternalWeakLinkage())
 268         ExtWeakSymbols.insert(GV);
 269
 270     EmitGlobalConstant(C);
 271     O << '\n';
 272   }
 273
 274   return AsmPrinter::doFinalization(M);
 275 }
 276
 277 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 278 ///
 279 bool AlphaAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 280                                       unsigned AsmVariant,
 281                                       const char *ExtraCode) {
 282   printOperand(MI, OpNo);
 283   return false;
 284 }
 285
 286 bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 287                                             unsigned OpNo,
 288                                             unsigned AsmVariant,
 289                                             const char *ExtraCode) {
 290   if (ExtraCode && ExtraCode[0])
 291     return true; // Unknown modifier.
 292   O << "0(";
 293   printOperand(MI, OpNo);
 294   O << ")";
 295   return false;
 296 }