lib/Target/SparcV9/SparcV9AsmPrinter.cpp

   1 //===-- EmitAssembly.cpp - Emit Sparc Specific .s File ---------------------==//
   2 //
   3 // This file implements all of the stuff neccesary to output a .s file from
   4 // LLVM.  The code in this file assumes that the specified module has already
   5 // been compiled into the internal data structures of the Module.
   6 //
   7 // This code largely consists of two LLVM Pass's: a FunctionPass and a Pass.
   8 // The FunctionPass is pipelined together with all of the rest of the code
   9 // generation stages, and the Pass runs at the end to emit code for global
  10 // variables and such.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SparcInternals.h"
  15 #include "llvm/CodeGen/MachineInstr.h"
  16 #include "llvm/CodeGen/MachineCodeForBasicBlock.h"
  17 #include "llvm/CodeGen/MachineCodeForMethod.h"
  18 #include "llvm/GlobalVariable.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/DerivedTypes.h"
  21 #include "llvm/Module.h"
  22 #include "llvm/SlotCalculator.h"
  23 #include "llvm/Pass.h"
  24 #include "llvm/Assembly/Writer.h"
  25 #include "Support/StringExtras.h"
  26 #include <iostream>
  27 using std::string;
  28
  29 namespace {
  30
  31 class GlobalIdTable: public Annotation {
  32   static AnnotationID AnnotId;
  33   friend class AsmPrinter;              // give access to AnnotId
  34
  35   typedef hash_map<const Value*, int> ValIdMap;
  36   typedef ValIdMap::const_iterator ValIdMapConstIterator;
  37   typedef ValIdMap::      iterator ValIdMapIterator;
  38 public:
  39   SlotCalculator Table;    // map anonymous values to unique integer IDs
  40   ValIdMap valToIdMap;     // used for values not handled by SlotCalculator
  41
  42   GlobalIdTable(Module* M) : Annotation(AnnotId), Table(M, true) {}
  43 };
  44
  45 AnnotationID GlobalIdTable::AnnotId =
  46   AnnotationManager::getID("ASM PRINTER GLOBAL TABLE ANNOT");
  47
  48 //===---------------------------------------------------------------------===//
  49 //   Code Shared By the two printer passes, as a mixin
  50 //===---------------------------------------------------------------------===//
  51
  52 class AsmPrinter {
  53   GlobalIdTable* idTable;
  54 public:
  55   std::ostream &toAsm;
  56   const TargetMachine &Target;
  57
  58   enum Sections {
  59     Unknown,
  60     Text,
  61     ReadOnlyData,
  62     InitRWData,
  63     UninitRWData,
  64   } CurSection;
  65
  66   AsmPrinter(std::ostream &os, const TargetMachine &T)
  67     : idTable(0), toAsm(os), Target(T), CurSection(Unknown) {}
  68
  69   // (start|end)(Module|Function) - Callback methods to be invoked by subclasses
  70   void startModule(Module &M) {
  71     // Create the global id table if it does not already exist
  72     idTable = (GlobalIdTable*)M.getAnnotation(GlobalIdTable::AnnotId);
  73     if (idTable == NULL) {
  74       idTable = new GlobalIdTable(&M);
  75       M.addAnnotation(idTable);
  76     }
  77   }
  78   void startFunction(Function &F) {
  79     // Make sure the slot table has information about this function...
  80     idTable->Table.incorporateFunction(&F);
  81   }
  82   void endFunction(Function &) {
  83     idTable->Table.purgeFunction();  // Forget all about F
  84   }
  85   void endModule() {
  86   }
  87
  88   // Check if a value is external or accessible from external code.
  89   bool isExternal(const Value* V) {
  90     const GlobalValue *GV = dyn_cast<GlobalValue>(V);
  91     return GV && GV->hasExternalLinkage();
  92   }
  93
  94   // enterSection - Use this method to enter a different section of the output
  95   // executable.  This is used to only output neccesary section transitions.
  96   //
  97   void enterSection(enum Sections S) {
  98     if (S == CurSection) return;        // Only switch section if neccesary
  99     CurSection = S;
 100
 101     toAsm << "\n\t.section ";
 102     switch (S)
 103       {
 104       default: assert(0 && "Bad section name!");
 105       case Text:         toAsm << "\".text\""; break;
 106       case ReadOnlyData: toAsm << "\".rodata\",#alloc"; break;
 107       case InitRWData:   toAsm << "\".data\",#alloc,#write"; break;
 108       case UninitRWData: toAsm << "\".bss\",#alloc,#write"; break;
 109       }
 110     toAsm << "\n";
 111   }
 112
 113   static std::string getValidSymbolName(const string &S) {
 114     string Result;
 115
 116     // Symbol names in Sparc assembly language have these rules:
 117     // (a) Must match { letter | _ | . | $ } { letter | _ | . | $ | digit }*
 118     // (b) A name beginning in "." is treated as a local name.
 119     // (c) Names beginning with "_" are reserved by ANSI C and shd not be used.
 120     //
 121     if (S[0] == '_' || isdigit(S[0]))
 122       Result += "ll";
 123
 124     for (unsigned i = 0; i < S.size(); ++i)
 125       {
 126         char C = S[i];
 127         if (C == '_' || C == '.' || C == '$' || isalpha(C) || isdigit(C))
 128           Result += C;
 129         else
 130           {
 131             Result += '_';
 132             Result += char('0' + ((unsigned char)C >> 4));
 133             Result += char('0' + (C & 0xF));
 134           }
 135       }
 136     return Result;
 137   }
 138
 139   // getID - Return a valid identifier for the specified value.  Base it on
 140   // the name of the identifier if possible (qualified by the type), and
 141   // use a numbered value based on prefix otherwise.
 142   // FPrefix is always prepended to the output identifier.
 143   //
 144   string getID(const Value *V, const char *Prefix, const char *FPrefix = 0) {
 145     string Result = FPrefix ? FPrefix : "";  // "Forced prefix"
 146
 147     Result +=  V->hasName() ? V->getName() : string(Prefix);
 148
 149     // Qualify all internal names with a unique id.
 150     if (!isExternal(V)) {
 151       int valId = idTable->Table.getValSlot(V);
 152       if (valId == -1) {
 153         GlobalIdTable::ValIdMapConstIterator I = idTable->valToIdMap.find(V);
 154         if (I == idTable->valToIdMap.end())
 155           valId = idTable->valToIdMap[V] = idTable->valToIdMap.size();
 156         else
 157           valId = I->second;
 158       }
 159       Result = Result + "_" + itostr(valId);
 160     }
 161
 162     return getValidSymbolName(Result);
 163   }
 164
 165   // getID Wrappers - Ensure consistent usage...
 166   string getID(const Function *F) {
 167     return getID(F, "LLVMFunction_");
 168   }
 169   string getID(const BasicBlock *BB) {
 170     return getID(BB, "LL", (".L_"+getID(BB->getParent())+"_").c_str());
 171   }
 172   string getID(const GlobalVariable *GV) {
 173     return getID(GV, "LLVMGlobal_");
 174   }
 175   string getID(const Constant *CV) {
 176     return getID(CV, "LLVMConst_", ".C_");
 177   }
 178   string getID(const GlobalValue *GV) {
 179     if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
 180       return getID(V);
 181     else if (const Function *F = dyn_cast<Function>(GV))
 182       return getID(F);
 183     assert(0 && "Unexpected type of GlobalValue!");
 184     return "";
 185   }
 186
 187   // ConstantExprToString() - Convert a ConstantExpr to an asm expression
 188   // and return this as a string.
 189   std::string ConstantExprToString(const ConstantExpr* CE,
 190                                    const TargetMachine& target) {
 191     std::string S;
 192
 193     switch(CE->getOpcode()) {
 194     case Instruction::GetElementPtr:
 195       { // generate a symbolic expression for the byte address
 196         const Value* ptrVal = CE->getOperand(0);
 197         std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
 198         S += "(" + valToExprString(ptrVal, target) + ") + ("
 199           + utostr(target.DataLayout.getIndexedOffset(ptrVal->getType(),idxVec))
 200           + ")";
 201         break;
 202       }
 203
 204     case Instruction::Cast:
 205       // Support only non-converting casts for now, i.e., a no-op.
 206       // This assertion is not a complete check.
 207       assert(target.DataLayout.getTypeSize(CE->getType()) ==
 208              target.DataLayout.getTypeSize(CE->getOperand(0)->getType()));
 209       S += "(" + valToExprString(CE->getOperand(0), target) + ")";
 210       break;
 211
 212     case Instruction::Add:
 213       S += "(" + valToExprString(CE->getOperand(0), target) + ") + ("
 214                + valToExprString(CE->getOperand(1), target) + ")";
 215       break;
 216
 217     default:
 218       assert(0 && "Unsupported operator in ConstantExprToString()");
 219       break;
 220     }
 221
 222     return S;
 223   }
 224
 225   // valToExprString - Helper function for ConstantExprToString().
 226   // Appends result to argument string S.
 227   //
 228   std::string valToExprString(const Value* V, const TargetMachine& target) {
 229     std::string S;
 230     bool failed = false;
 231     if (const Constant* CV = dyn_cast<Constant>(V)) { // symbolic or known
 232
 233       if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV))
 234         S += std::string(CB == ConstantBool::True ? "1" : "0");
 235       else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV))
 236         S += itostr(CI->getValue());
 237       else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
 238         S += utostr(CI->getValue());
 239       else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV))
 240         S += ftostr(CFP->getValue());
 241       else if (isa<ConstantPointerNull>(CV))
 242         S += "0";
 243       else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(CV))
 244         S += valToExprString(CPR->getValue(), target);
 245       else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV))
 246         S += ConstantExprToString(CE, target);
 247       else
 248         failed = true;
 249
 250     } else if (const GlobalValue* GV = dyn_cast<GlobalValue>(V)) {
 251       S += getID(GV);
 252     }
 253     else
 254       failed = true;
 255
 256     if (failed) {
 257       assert(0 && "Cannot convert value to string");
 258       S += "<illegal-value>";
 259     }
 260     return S;
 261   }
 262
 263 };
 264
 265
 266
 267 //===----------------------------------------------------------------------===//
 268 //   SparcFunctionAsmPrinter Code
 269 //===----------------------------------------------------------------------===//
 270
 271 struct SparcFunctionAsmPrinter : public FunctionPass, public AsmPrinter {
 272   inline SparcFunctionAsmPrinter(std::ostream &os, const TargetMachine &t)
 273     : AsmPrinter(os, t) {}
 274
 275   const char *getPassName() const {
 276     return "Output Sparc Assembly for Functions";
 277   }
 278
 279   virtual bool doInitialization(Module &M) {
 280     startModule(M);
 281     return false;
 282   }
 283
 284   virtual bool runOnFunction(Function &F) {
 285     startFunction(F);
 286     emitFunction(F);
 287     endFunction(F);
 288     return false;
 289   }
 290
 291   virtual bool doFinalization(Module &M) {
 292     endModule();
 293     return false;
 294   }
 295
 296   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 297     AU.setPreservesAll();
 298   }
 299
 300   void emitFunction(const Function &F);
 301 private :
 302   void emitBasicBlock(const BasicBlock *BB);
 303   void emitMachineInst(const MachineInstr *MI);
 304
 305   unsigned int printOperands(const MachineInstr *MI, unsigned int opNum);
 306   void printOneOperand(const MachineOperand &Op);
 307
 308   bool OpIsBranchTargetLabel(const MachineInstr *MI, unsigned int opNum);
 309   bool OpIsMemoryAddressBase(const MachineInstr *MI, unsigned int opNum);
 310
 311   unsigned getOperandMask(unsigned Opcode) {
 312     switch (Opcode) {
 313     case SUBcc:   return 1 << 3;  // Remove CC argument
 314   //case BA:      return 1 << 0;  // Remove Arg #0, which is always null or xcc
 315     default:      return 0;       // By default, don't hack operands...
 316     }
 317   }
 318 };
 319
 320 inline bool
 321 SparcFunctionAsmPrinter::OpIsBranchTargetLabel(const MachineInstr *MI,
 322                                                unsigned int opNum) {
 323   switch (MI->getOpCode()) {
 324   case JMPLCALL:
 325   case JMPLRET: return (opNum == 0);
 326   default:      return false;
 327   }
 328 }
 329
 330
 331 inline bool
 332 SparcFunctionAsmPrinter::OpIsMemoryAddressBase(const MachineInstr *MI,
 333                                                unsigned int opNum) {
 334   if (Target.getInstrInfo().isLoad(MI->getOpCode()))
 335     return (opNum == 0);
 336   else if (Target.getInstrInfo().isStore(MI->getOpCode()))
 337     return (opNum == 1);
 338   else
 339     return false;
 340 }
 341
 342
 343 #define PrintOp1PlusOp2(mop1, mop2) \
 344   printOneOperand(mop1); \
 345   toAsm << "+"; \
 346   printOneOperand(mop2);
 347
 348 unsigned int
 349 SparcFunctionAsmPrinter::printOperands(const MachineInstr *MI,
 350                                unsigned int opNum)
 351 {
 352   const MachineOperand& mop = MI->getOperand(opNum);
 353
 354   if (OpIsBranchTargetLabel(MI, opNum))
 355     {
 356       PrintOp1PlusOp2(mop, MI->getOperand(opNum+1));
 357       return 2;
 358     }
 359   else if (OpIsMemoryAddressBase(MI, opNum))
 360     {
 361       toAsm << "[";
 362       PrintOp1PlusOp2(mop, MI->getOperand(opNum+1));
 363       toAsm << "]";
 364       return 2;
 365     }
 366   else
 367     {
 368       printOneOperand(mop);
 369       return 1;
 370     }
 371 }
 372
 373
 374 void
 375 SparcFunctionAsmPrinter::printOneOperand(const MachineOperand &mop)
 376 {
 377   bool needBitsFlag = true;
 378
 379   if (mop.opHiBits32())
 380     toAsm << "%lm(";
 381   else if (mop.opLoBits32())
 382     toAsm << "%lo(";
 383   else if (mop.opHiBits64())
 384     toAsm << "%hh(";
 385   else if (mop.opLoBits64())
 386     toAsm << "%hm(";
 387   else
 388     needBitsFlag = false;
 389
 390   switch (mop.getOperandType())
 391     {
 392     case MachineOperand::MO_VirtualRegister:
 393     case MachineOperand::MO_CCRegister:
 394     case MachineOperand::MO_MachineRegister:
 395       {
 396         int RegNum = (int)mop.getAllocatedRegNum();
 397
 398         // better to print code with NULL registers than to die
 399         if (RegNum == Target.getRegInfo().getInvalidRegNum()) {
 400           toAsm << "<NULL VALUE>";
 401         } else {
 402           toAsm << "%" << Target.getRegInfo().getUnifiedRegName(RegNum);
 403         }
 404         break;
 405       }
 406
 407     case MachineOperand::MO_PCRelativeDisp:
 408       {
 409         const Value *Val = mop.getVRegValue();
 410         assert(Val && "\tNULL Value in SparcFunctionAsmPrinter");
 411
 412         if (const BasicBlock *BB = dyn_cast<const BasicBlock>(Val))
 413           toAsm << getID(BB);
 414         else if (const Function *M = dyn_cast<Function>(Val))
 415           toAsm << getID(M);
 416         else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Val))
 417           toAsm << getID(GV);
 418         else if (const Constant *CV = dyn_cast<Constant>(Val))
 419           toAsm << getID(CV);
 420         else
 421           assert(0 && "Unrecognized value in SparcFunctionAsmPrinter");
 422         break;
 423       }
 424
 425     case MachineOperand::MO_SignExtendedImmed:
 426       toAsm << mop.getImmedValue();
 427       break;
 428
 429     case MachineOperand::MO_UnextendedImmed:
 430       toAsm << (uint64_t) mop.getImmedValue();
 431       break;
 432
 433     default:
 434       toAsm << mop;      // use dump field
 435       break;
 436     }
 437
 438   if (needBitsFlag)
 439     toAsm << ")";
 440 }
 441
 442
 443 void
 444 SparcFunctionAsmPrinter::emitMachineInst(const MachineInstr *MI)
 445 {
 446   unsigned Opcode = MI->getOpCode();
 447
 448   if (TargetInstrDescriptors[Opcode].iclass & M_DUMMY_PHI_FLAG)
 449     return;  // IGNORE PHI NODES
 450
 451   toAsm << "\t" << TargetInstrDescriptors[Opcode].opCodeString << "\t";
 452
 453   unsigned Mask = getOperandMask(Opcode);
 454
 455   bool NeedComma = false;
 456   unsigned N = 1;
 457   for (unsigned OpNum = 0; OpNum < MI->getNumOperands(); OpNum += N)
 458     if (! ((1 << OpNum) & Mask)) {        // Ignore this operand?
 459       if (NeedComma) toAsm << ", ";         // Handle comma outputing
 460       NeedComma = true;
 461       N = printOperands(MI, OpNum);
 462     }
 463   else
 464     N = 1;
 465
 466   toAsm << "\n";
 467 }
 468
 469 void
 470 SparcFunctionAsmPrinter::emitBasicBlock(const BasicBlock *BB)
 471 {
 472   // Emit a label for the basic block
 473   toAsm << getID(BB) << ":\n";
 474
 475   // Get the vector of machine instructions corresponding to this bb.
 476   const MachineCodeForBasicBlock &MIs = MachineCodeForBasicBlock::get(BB);
 477   MachineCodeForBasicBlock::const_iterator MII = MIs.begin(), MIE = MIs.end();
 478
 479   // Loop over all of the instructions in the basic block...
 480   for (; MII != MIE; ++MII)
 481     emitMachineInst(*MII);
 482   toAsm << "\n";  // Seperate BB's with newlines
 483 }
 484
 485 void
 486 SparcFunctionAsmPrinter::emitFunction(const Function &F)
 487 {
 488   string methName = getID(&F);
 489   toAsm << "!****** Outputing Function: " << methName << " ******\n";
 490   enterSection(AsmPrinter::Text);
 491   toAsm << "\t.align\t4\n\t.global\t" << methName << "\n";
 492   //toAsm << "\t.type\t" << methName << ",#function\n";
 493   toAsm << "\t.type\t" << methName << ", 2\n";
 494   toAsm << methName << ":\n";
 495
 496   // Output code for all of the basic blocks in the function...
 497   for (Function::const_iterator I = F.begin(), E = F.end(); I != E; ++I)
 498     emitBasicBlock(I);
 499
 500   // Output a .size directive so the debugger knows the extents of the function
 501   toAsm << ".EndOf_" << methName << ":\n\t.size "
 502            << methName << ", .EndOf_"
 503            << methName << "-" << methName << "\n";
 504
 505   // Put some spaces between the functions
 506   toAsm << "\n\n";
 507 }
 508
 509 }  // End anonymous namespace
 510
 511 Pass *UltraSparc::getFunctionAsmPrinterPass(std::ostream &Out) {
 512   return new SparcFunctionAsmPrinter(Out, *this);
 513 }
 514
 515
 516
 517
 518
 519 //===----------------------------------------------------------------------===//
 520 //   SparcFunctionAsmPrinter Code
 521 //===----------------------------------------------------------------------===//
 522
 523 namespace {
 524
 525 class SparcModuleAsmPrinter : public Pass, public AsmPrinter {
 526 public:
 527   SparcModuleAsmPrinter(std::ostream &os, TargetMachine &t)
 528     : AsmPrinter(os, t) {}
 529
 530   const char *getPassName() const { return "Output Sparc Assembly for Module"; }
 531
 532   virtual bool run(Module &M) {
 533     startModule(M);
 534     emitGlobalsAndConstants(M);
 535     endModule();
 536     return false;
 537   }
 538
 539   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 540     AU.setPreservesAll();
 541   }
 542
 543 private:
 544   void emitGlobalsAndConstants(const Module &M);
 545
 546   void printGlobalVariable(const GlobalVariable *GV);
 547   void printSingleConstant(   const Constant* CV);
 548   void printConstantValueOnly(const Constant* CV);
 549   void printConstant(         const Constant* CV, std::string valID = "");
 550
 551   static void FoldConstants(const Module &M,
 552                             hash_set<const Constant*> &moduleConstants);
 553 };
 554
 555
 556 // Can we treat the specified array as a string?  Only if it is an array of
 557 // ubytes or non-negative sbytes.
 558 //
 559 static bool isStringCompatible(const ConstantArray *CPA) {
 560   const Type *ETy = cast<ArrayType>(CPA->getType())->getElementType();
 561   if (ETy == Type::UByteTy) return true;
 562   if (ETy != Type::SByteTy) return false;
 563
 564   for (unsigned i = 0; i < CPA->getNumOperands(); ++i)
 565     if (cast<ConstantSInt>(CPA->getOperand(i))->getValue() < 0)
 566       return false;
 567
 568   return true;
 569 }
 570
 571 // toOctal - Convert the low order bits of X into an octal letter
 572 static inline char toOctal(int X) {
 573   return (X&7)+'0';
 574 }
 575
 576 // getAsCString - Return the specified array as a C compatible string, only if
 577 // the predicate isStringCompatible is true.
 578 //
 579 static string getAsCString(const ConstantArray *CPA) {
 580   assert(isStringCompatible(CPA) && "Array is not string compatible!");
 581
 582   string Result;
 583   const Type *ETy = cast<ArrayType>(CPA->getType())->getElementType();
 584   Result = "\"";
 585   for (unsigned i = 0; i < CPA->getNumOperands(); ++i) {
 586     unsigned char C = (ETy == Type::SByteTy) ?
 587       (unsigned char)cast<ConstantSInt>(CPA->getOperand(i))->getValue() :
 588       (unsigned char)cast<ConstantUInt>(CPA->getOperand(i))->getValue();
 589
 590     if (C == '"') {
 591       Result += "\\\"";
 592     } else if (isprint(C)) {
 593       Result += C;
 594     } else {
 595       switch(C) {
 596       case '\a': Result += "\\a"; break;
 597       case '\b': Result += "\\b"; break;
 598       case '\f': Result += "\\f"; break;
 599       case '\n': Result += "\\n"; break;
 600       case '\r': Result += "\\r"; break;
 601       case '\t': Result += "\\t"; break;
 602       case '\v': Result += "\\v"; break;
 603       default:
 604         Result += '\\';
 605         Result += toOctal(C >> 6);
 606         Result += toOctal(C >> 3);
 607         Result += toOctal(C >> 0);
 608         break;
 609       }
 610     }
 611   }
 612   Result += "\"";
 613
 614   return Result;
 615 }
 616
 617 inline bool
 618 ArrayTypeIsString(const ArrayType* arrayType)
 619 {
 620   return (arrayType->getElementType() == Type::UByteTy ||
 621           arrayType->getElementType() == Type::SByteTy);
 622 }
 623
 624
 625 inline const string
 626 TypeToDataDirective(const Type* type)
 627 {
 628   switch(type->getPrimitiveID())
 629     {
 630     case Type::BoolTyID: case Type::UByteTyID: case Type::SByteTyID:
 631       return ".byte";
 632     case Type::UShortTyID: case Type::ShortTyID:
 633       return ".half";
 634     case Type::UIntTyID: case Type::IntTyID:
 635       return ".word";
 636     case Type::ULongTyID: case Type::LongTyID: case Type::PointerTyID:
 637       return ".xword";
 638     case Type::FloatTyID:
 639       return ".word";
 640     case Type::DoubleTyID:
 641       return ".xword";
 642     case Type::ArrayTyID:
 643       if (ArrayTypeIsString((ArrayType*) type))
 644         return ".ascii";
 645       else
 646         return "<InvaliDataTypeForPrinting>";
 647     default:
 648       return "<InvaliDataTypeForPrinting>";
 649     }
 650 }
 651
 652 // Get the size of the constant for the given target.
 653 // If this is an unsized array, return 0.
 654 //
 655 inline unsigned int
 656 ConstantToSize(const Constant* CV, const TargetMachine& target)
 657 {
 658   if (const ConstantArray* CPA = dyn_cast<ConstantArray>(CV))
 659     {
 660       const ArrayType *aty = cast<ArrayType>(CPA->getType());
 661       if (ArrayTypeIsString(aty))
 662         return 1 + CPA->getNumOperands();
 663     }
 664
 665   return target.findOptimalStorageSize(CV->getType());
 666 }
 667
 668
 669
 670 // Align data larger than one L1 cache line on L1 cache line boundaries.
 671 // Align all smaller data on the next higher 2^x boundary (4, 8, ...).
 672 //
 673 inline unsigned int
 674 SizeToAlignment(unsigned int size, const TargetMachine& target)
 675 {
 676   unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1);
 677   if (size > (unsigned) cacheLineSize / 2)
 678     return cacheLineSize;
 679   else
 680     for (unsigned sz=1; /*no condition*/; sz *= 2)
 681       if (sz >= size)
 682         return sz;
 683 }
 684
 685 // Get the size of the type and then use SizeToAlignment.
 686 //
 687 inline unsigned int
 688 TypeToAlignment(const Type* type, const TargetMachine& target)
 689 {
 690   return SizeToAlignment(target.findOptimalStorageSize(type), target);
 691 }
 692
 693 // Get the size of the constant and then use SizeToAlignment.
 694 // Handles strings as a special case;
 695 inline unsigned int
 696 ConstantToAlignment(const Constant* CV, const TargetMachine& target)
 697 {
 698   if (const ConstantArray* CPA = dyn_cast<ConstantArray>(CV))
 699     if (ArrayTypeIsString(cast<ArrayType>(CPA->getType())))
 700       return SizeToAlignment(1 + CPA->getNumOperands(), target);
 701
 702   return TypeToAlignment(CV->getType(), target);
 703 }
 704
 705
 706 // Print a single constant value.
 707 void
 708 SparcModuleAsmPrinter::printSingleConstant(const Constant* CV)
 709 {
 710   assert(CV->getType() != Type::VoidTy &&
 711          CV->getType() != Type::TypeTy &&
 712          CV->getType() != Type::LabelTy &&
 713          "Unexpected type for Constant");
 714
 715   assert((!isa<ConstantArray>(CV) && ! isa<ConstantStruct>(CV))
 716          && "Aggregate types should be handled outside this function");
 717
 718   toAsm << "\t" << TypeToDataDirective(CV->getType()) << "\t";
 719
 720   if (CV->getType()->isPrimitiveType())
 721     {
 722       if (CV->getType()->isFloatingPoint()) {
 723         // FP Constants are printed as integer constants to avoid losing
 724         // precision...
 725         double Val = cast<ConstantFP>(CV)->getValue();
 726         if (CV->getType() == Type::FloatTy) {
 727           float FVal = (float)Val;
 728           char *ProxyPtr = (char*)&FVal;        // Abide by C TBAA rules
 729           toAsm << *(unsigned int*)ProxyPtr;
 730         } else if (CV->getType() == Type::DoubleTy) {
 731           char *ProxyPtr = (char*)&Val;         // Abide by C TBAA rules
 732           toAsm << *(uint64_t*)ProxyPtr;
 733         } else {
 734           assert(0 && "Unknown floating point type!");
 735         }
 736
 737         toAsm << "\t! " << CV->getType()->getDescription()
 738               << " value: " << Val << "\n";
 739       } else {
 740         WriteAsOperand(toAsm, CV, false, false) << "\n";
 741       }
 742     }
 743   else if (const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(CV))
 744     { // This is a constant address for a global variable or method.
 745       // Use the name of the variable or method as the address value.
 746       toAsm << getID(CPR->getValue()) << "\n";
 747     }
 748   else if (isa<ConstantPointerNull>(CV))
 749     { // Null pointer value
 750       toAsm << "0\n";
 751     }
 752   else if (const ConstantExpr* CE = dyn_cast<ConstantExpr>(CV))
 753     { // Constant expression built from operators, constants, and symbolic addrs
 754       toAsm << ConstantExprToString(CE, Target) << "\n";
 755     }
 756   else
 757     {
 758       assert(0 && "Unknown elementary type for constant");
 759     }
 760 }
 761
 762 // Print a constant value or values (it may be an aggregate).
 763 // Uses printSingleConstant() to print each individual value.
 764 void
 765 SparcModuleAsmPrinter::printConstantValueOnly(const Constant* CV)
 766 {
 767   const ConstantArray *CPA = dyn_cast<ConstantArray>(CV);
 768
 769   if (CPA && isStringCompatible(CPA))
 770     { // print the string alone and return
 771       toAsm << "\t" << ".ascii" << "\t" << getAsCString(CPA) << "\n";
 772     }
 773   else if (CPA)
 774     { // Not a string.  Print the values in successive locations
 775       const std::vector<Use> &constValues = CPA->getValues();
 776       for (unsigned i=0; i < constValues.size(); i++)
 777         printConstantValueOnly(cast<Constant>(constValues[i].get()));
 778     }
 779   else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CV))
 780     { // Print the fields in successive locations
 781       const std::vector<Use>& constValues = CPS->getValues();
 782       for (unsigned i=0; i < constValues.size(); i++)
 783         printConstantValueOnly(cast<Constant>(constValues[i].get()));
 784     }
 785   else
 786     printSingleConstant(CV);
 787 }
 788
 789 // Print a constant (which may be an aggregate) prefixed by all the
 790 // appropriate directives.  Uses printConstantValueOnly() to print the
 791 // value or values.
 792 void
 793 SparcModuleAsmPrinter::printConstant(const Constant* CV, string valID)
 794 {
 795   if (valID.length() == 0)
 796     valID = getID(CV);
 797
 798   toAsm << "\t.align\t" << ConstantToAlignment(CV, Target) << "\n";
 799
 800   // Print .size and .type only if it is not a string.
 801   const ConstantArray *CPA = dyn_cast<ConstantArray>(CV);
 802   if (CPA && isStringCompatible(CPA))
 803     { // print it as a string and return
 804       toAsm << valID << ":\n";
 805       toAsm << "\t" << ".ascii" << "\t" << getAsCString(CPA) << "\n";
 806       return;
 807     }
 808
 809   toAsm << "\t.type" << "\t" << valID << ",#object\n";
 810
 811   unsigned int constSize = ConstantToSize(CV, Target);
 812   if (constSize)
 813     toAsm << "\t.size" << "\t" << valID << "," << constSize << "\n";
 814
 815   toAsm << valID << ":\n";
 816
 817   printConstantValueOnly(CV);
 818 }
 819
 820
 821 void SparcModuleAsmPrinter::FoldConstants(const Module &M,
 822                                           hash_set<const Constant*> &MC) {
 823   for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
 824     if (!I->isExternal()) {
 825       const hash_set<const Constant*> &pool =
 826         MachineCodeForMethod::get(I).getConstantPoolValues();
 827       MC.insert(pool.begin(), pool.end());
 828     }
 829 }
 830
 831 void SparcModuleAsmPrinter::printGlobalVariable(const GlobalVariable* GV)
 832 {
 833   if (GV->hasExternalLinkage())
 834     toAsm << "\t.global\t" << getID(GV) << "\n";
 835
 836   if (GV->hasInitializer())
 837     printConstant(GV->getInitializer(), getID(GV));
 838   else {
 839     toAsm << "\t.align\t" << TypeToAlignment(GV->getType()->getElementType(),
 840                                                 Target) << "\n";
 841     toAsm << "\t.type\t" << getID(GV) << ",#object\n";
 842     toAsm << "\t.reserve\t" << getID(GV) << ","
 843           << Target.findOptimalStorageSize(GV->getType()->getElementType())
 844           << "\n";
 845   }
 846 }
 847
 848
 849 void SparcModuleAsmPrinter::emitGlobalsAndConstants(const Module &M) {
 850   // First, get the constants there were marked by the code generator for
 851   // inclusion in the assembly code data area and fold them all into a
 852   // single constant pool since there may be lots of duplicates.  Also,
 853   // lets force these constants into the slot table so that we can get
 854   // unique names for unnamed constants also.
 855   //
 856   hash_set<const Constant*> moduleConstants;
 857   FoldConstants(M, moduleConstants);
 858
 859   // Output constants spilled to memory
 860   enterSection(AsmPrinter::ReadOnlyData);
 861   for (hash_set<const Constant*>::const_iterator I = moduleConstants.begin(),
 862          E = moduleConstants.end();  I != E; ++I)
 863     printConstant(*I);
 864
 865   // Output global variables...
 866   for (Module::const_giterator GI = M.gbegin(), GE = M.gend(); GI != GE; ++GI) {
 867     if (GI->hasInitializer() && GI->isConstant()) {
 868       enterSection(AsmPrinter::ReadOnlyData);  // read-only, initialized data
 869     } else if (GI->hasInitializer() && !GI->isConstant()) { // read-write data
 870       enterSection(AsmPrinter::InitRWData);
 871     } else {
 872       assert (!GI->hasInitializer() && "Unexpected global variable type found");
 873       enterSection(AsmPrinter::UninitRWData);       // Uninitialized data
 874     }
 875     printGlobalVariable(GI);
 876   }
 877
 878   toAsm << "\n";
 879 }
 880
 881 }  // End anonymous namespace
 882
 883 Pass *UltraSparc::getModuleAsmPrinterPass(std::ostream &Out) {
 884   return new SparcModuleAsmPrinter(Out, *this);
 885 }