lib/Target/Alpha/AlphaAsmPrinter.cpp

   1 //===-- AlphaAsmPrinter.cpp - Alpha LLVM assembly writer ------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source 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(MRegisterInfo::isPhysicalRegister(MO.getReg())&&"Not physreg??");
  79     O << TM.getRegisterInfo()->get(MO.getReg()).Name;
  80   } else if (MO.isImmediate()) {
  81     O << MO.getImmedValue();
  82     assert(MO.getImmedValue() < (1 << 30));
  83   } else {
  84     printOp(MO);
  85   }
  86 }
  87
  88
  89 void AlphaAsmPrinter::printOp(const MachineOperand &MO, bool IsCallOp) {
  90   const MRegisterInfo &RI = *TM.getRegisterInfo();
  91
  92   switch (MO.getType()) {
  93   case MachineOperand::MO_Register:
  94     O << RI.get(MO.getReg()).Name;
  95     return;
  96
  97   case MachineOperand::MO_Immediate:
  98     cerr << "printOp() does not handle immediate values\n";
  99     abort();
 100     return;
 101
 102   case MachineOperand::MO_MachineBasicBlock:
 103     printBasicBlockLabel(MO.getMachineBasicBlock());
 104     return;
 105
 106   case MachineOperand::MO_ConstantPoolIndex:
 107     O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
 108       << MO.getConstantPoolIndex();
 109     return;
 110
 111   case MachineOperand::MO_ExternalSymbol:
 112     O << MO.getSymbolName();
 113     return;
 114
 115   case MachineOperand::MO_GlobalAddress: {
 116     GlobalValue *GV = MO.getGlobal();
 117     O << Mang->getValueName(GV);
 118     if (GV->isDeclaration() && GV->hasExternalWeakLinkage())
 119       ExtWeakSymbols.insert(GV);
 120     return;
 121   }
 122
 123   case MachineOperand::MO_JumpTableIndex:
 124     O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 125       << '_' << MO.getJumpTableIndex();
 126     return;
 127
 128   default:
 129     O << "<unknown operand type: " << MO.getType() << ">";
 130     return;
 131   }
 132 }
 133
 134 /// runOnMachineFunction - This uses the printMachineInstruction()
 135 /// method to print assembly for each instruction.
 136 ///
 137 bool AlphaAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 138   SetupMachineFunction(MF);
 139   O << "\n\n";
 140
 141   // Print out constants referenced by the function
 142   EmitConstantPool(MF.getConstantPool());
 143
 144   // Print out jump tables referenced by the function
 145   EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
 146
 147   // Print out labels for the function.
 148   const Function *F = MF.getFunction();
 149   SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
 150
 151   EmitAlignment(4, F);
 152   switch (F->getLinkage()) {
 153   default: assert(0 && "Unknown linkage type!");
 154   case Function::InternalLinkage:  // Symbols default to internal.
 155     break;
 156    case Function::ExternalLinkage:
 157      O << "\t.globl " << CurrentFnName << "\n";
 158      break;
 159   case Function::WeakLinkage:
 160   case Function::LinkOnceLinkage:
 161     O << TAI->getWeakRefDirective() << CurrentFnName << "\n";
 162     break;
 163   }
 164
 165   O << "\t.ent " << CurrentFnName << "\n";
 166
 167   O << CurrentFnName << ":\n";
 168
 169   // Print out code for the function.
 170   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 171        I != E; ++I) {
 172     if (I != MF.begin()) {
 173       printBasicBlockLabel(I, true);
 174       O << '\n';
 175     }
 176     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 177          II != E; ++II) {
 178       // Print the assembly for the instruction.
 179       ++EmittedInsts;
 180       O << "\t";
 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       O << TAI->getWeakRefDirective() << name << '\n';
 229       break;
 230     case GlobalValue::AppendingLinkage:
 231     case GlobalValue::ExternalLinkage:
 232       O << "\t.globl " << name << "\n";
 233       break;
 234     case GlobalValue::InternalLinkage:
 235       break;
 236     default:
 237       assert(0 && "Unknown linkage type!");
 238       cerr << "Unknown linkage type!\n";
 239       abort();
 240     }
 241
 242     //3: Section (if changed)
 243     if (I->hasSection() &&
 244         (I->getSection() == ".ctors" ||
 245          I->getSection() == ".dtors")) {
 246       std::string SectionName = ".section\t" + I->getSection()
 247         + ",\"aw\",@progbits";
 248       SwitchToDataSection(SectionName.c_str());
 249     } else {
 250       if (C->isNullValue())
 251         SwitchToDataSection("\t.section\t.bss", I);
 252       else
 253         SwitchToDataSection("\t.section\t.data", I);
 254     }
 255
 256     //4: Type, Size, Align
 257     O << "\t.type\t" << name << ", @object\n";
 258     O << "\t.size\t" << name << ", " << Size << "\n";
 259     EmitAlignment(Align, I);
 260
 261     O << name << ":\n";
 262
 263     // If the initializer is a extern weak symbol, remember to emit the weak
 264     // reference!
 265     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 266       if (GV->hasExternalWeakLinkage())
 267         ExtWeakSymbols.insert(GV);
 268
 269     EmitGlobalConstant(C);
 270     O << '\n';
 271   }
 272
 273   return AsmPrinter::doFinalization(M);
 274 }
 275
 276 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 277 ///
 278 bool AlphaAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 279                                       unsigned AsmVariant,
 280                                       const char *ExtraCode) {
 281   printOperand(MI, OpNo);
 282   return false;
 283 }
 284
 285 bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 286                                             unsigned OpNo,
 287                                             unsigned AsmVariant,
 288                                             const char *ExtraCode) {
 289   if (ExtraCode && ExtraCode[0])
 290     return true; // Unknown modifier.
 291   O << "0(";
 292   printOperand(MI, OpNo);
 293   O << ")";
 294   return false;
 295 }