lib/Target/PIC16/AsmPrinter/PIC16AsmPrinter.cpp

   1 //===-- PIC16AsmPrinter.cpp - PIC16 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 PIC16 assembly language.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "PIC16ABINames.h"
  16 #include "PIC16AsmPrinter.h"
  17 #include "PIC16Section.h"
  18 #include "PIC16MCAsmInfo.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Function.h"
  21 #include "llvm/Module.h"
  22 #include "llvm/CodeGen/DwarfWriter.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/DwarfWriter.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/MC/MCSymbol.h"
  28 #include "llvm/Target/TargetRegistry.h"
  29 #include "llvm/Target/TargetLoweringObjectFile.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/FormattedStream.h"
  32 #include "llvm/Support/Mangler.h"
  33 #include <cstring>
  34 using namespace llvm;
  35
  36 #include "PIC16GenAsmWriter.inc"
  37
  38 PIC16AsmPrinter::PIC16AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
  39                                  const MCAsmInfo *T, bool V)
  40 : AsmPrinter(O, TM, T, V), DbgInfo(O, T) {
  41   PTLI = static_cast<PIC16TargetLowering*>(TM.getTargetLowering());
  42   PMAI = static_cast<const PIC16MCAsmInfo*>(T);
  43   PTOF = (PIC16TargetObjectFile *)&PTLI->getObjFileLowering();
  44 }
  45
  46 bool PIC16AsmPrinter::printMachineInstruction(const MachineInstr *MI) {
  47   processDebugLoc(MI, true);
  48   printInstruction(MI);
  49   if (VerboseAsm)
  50     EmitComments(*MI);
  51   O << '\n';
  52   processDebugLoc(MI, false);
  53   return true;
  54 }
  55
  56 static int getFunctionColor(const Function *F) {
  57   if (F->hasSection()) {
  58     std::string Sectn = F->getSection();
  59     std::string StrToFind = "Overlay=";
  60     std::string::size_type Pos = Sectn.find(StrToFind);
  61
  62     // Retreive the color number if the key is found.
  63     if (Pos != std::string::npos) {
  64       Pos += StrToFind.length();
  65       std::string Color = "";
  66       char c = Sectn.at(Pos);
  67       // A Color can only consist of digits.
  68       while (c >= '0' && c<= '9') {
  69         Color.append(1,c);
  70         Pos++;
  71         if (Pos >= Sectn.length())
  72           break;
  73         c = Sectn.at(Pos);
  74       }
  75       return atoi(Color.c_str());
  76     }
  77   }
  78
  79   // Color was not set for function, so return -1.
  80   return -1;
  81 }
  82
  83 // Color the Auto section of the given function.
  84 void PIC16AsmPrinter::ColorAutoSection(const Function *F) {
  85   std::string SectionName = PAN::getAutosSectionName(CurrentFnName);
  86   PIC16Section* Section = PTOF->findPIC16Section(SectionName);
  87   if (Section != NULL) {
  88     int Color = getFunctionColor(F);
  89     if (Color >= 0)
  90       Section->setColor(Color);
  91   }
  92 }
  93
  94
  95 /// runOnMachineFunction - This emits the frame section, autos section and
  96 /// assembly for each instruction. Also takes care of function begin debug
  97 /// directive and file begin debug directive (if required) for the function.
  98 ///
  99 bool PIC16AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 100   this->MF = &MF;
 101
 102   // This calls the base class function required to be called at beginning
 103   // of runOnMachineFunction.
 104   SetupMachineFunction(MF);
 105
 106   // Get the mangled name.
 107   const Function *F = MF.getFunction();
 108   CurrentFnName = Mang->getMangledName(F);
 109
 110   // Put the color information from function to its auto section.
 111   ColorAutoSection(F);
 112
 113   // Emit the function frame (args and temps).
 114   EmitFunctionFrame(MF);
 115
 116   DbgInfo.BeginFunction(MF);
 117
 118   // Now emit the instructions of function in its code section.
 119   const MCSection *fCodeSection
 120     = getObjFileLowering().SectionForCode(CurrentFnName);
 121
 122   // Start the Code Section.
 123   O <<  "\n";
 124   OutStreamer.SwitchSection(fCodeSection);
 125
 126   // Emit the frame address of the function at the beginning of code.
 127   O << "\tretlw  low(" << PAN::getFrameLabel(CurrentFnName) << ")\n";
 128   O << "\tretlw  high(" << PAN::getFrameLabel(CurrentFnName) << ")\n";
 129
 130   // Emit function start label.
 131   O << CurrentFnName << ":\n";
 132
 133   DebugLoc CurDL;
 134   O << "\n";
 135   // Print out code for the function.
 136   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 137        I != E; ++I) {
 138
 139     // Print a label for the basic block.
 140     if (I != MF.begin()) {
 141       EmitBasicBlockStart(I);
 142     }
 143
 144     // Print a basic block.
 145     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 146          II != E; ++II) {
 147
 148       // Emit the line directive if source line changed.
 149       const DebugLoc DL = II->getDebugLoc();
 150       if (!DL.isUnknown() && DL != CurDL) {
 151         DbgInfo.ChangeDebugLoc(MF, DL);
 152         CurDL = DL;
 153       }
 154
 155       // Print the assembly for the instruction.
 156       printMachineInstruction(II);
 157     }
 158   }
 159
 160   // Emit function end debug directives.
 161   DbgInfo.EndFunction(MF);
 162
 163   return false;  // we didn't modify anything.
 164 }
 165
 166
 167 // printOperand - print operand of insn.
 168 void PIC16AsmPrinter::printOperand(const MachineInstr *MI, int opNum) {
 169   const MachineOperand &MO = MI->getOperand(opNum);
 170
 171   switch (MO.getType()) {
 172     case MachineOperand::MO_Register:
 173       O << getRegisterName(MO.getReg());
 174       return;
 175
 176     case MachineOperand::MO_Immediate:
 177       O << (int)MO.getImm();
 178       return;
 179
 180     case MachineOperand::MO_GlobalAddress: {
 181       std::string Sname = Mang->getMangledName(MO.getGlobal());
 182       // FIXME: currently we do not have a memcpy def coming in the module
 183       // by any chance, as we do not link in those as .bc lib. So these calls
 184       // are always external and it is safe to emit an extern.
 185       if (PAN::isMemIntrinsic(Sname)) {
 186         LibcallDecls.push_back(createESName(Sname));
 187       }
 188
 189       O << Sname;
 190       break;
 191     }
 192     case MachineOperand::MO_ExternalSymbol: {
 193        const char *Sname = MO.getSymbolName();
 194
 195       // If its a libcall name, record it to decls section.
 196       if (PAN::getSymbolTag(Sname) == PAN::LIBCALL) {
 197         LibcallDecls.push_back(Sname);
 198       }
 199
 200       // Record a call to intrinsic to print the extern declaration for it.
 201       std::string Sym = Sname;
 202       if (PAN::isMemIntrinsic(Sym)) {
 203         Sym = PAN::addPrefix(Sym);
 204         LibcallDecls.push_back(createESName(Sym));
 205       }
 206
 207       O  << Sym;
 208       break;
 209     }
 210     case MachineOperand::MO_MachineBasicBlock:
 211       GetMBBSymbol(MO.getMBB()->getNumber())->print(O, MAI);
 212       return;
 213
 214     default:
 215       llvm_unreachable(" Operand type not supported.");
 216   }
 217 }
 218
 219 /// printCCOperand - Print the cond code operand.
 220 ///
 221 void PIC16AsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) {
 222   int CC = (int)MI->getOperand(opNum).getImm();
 223   O << PIC16CondCodeToString((PIC16CC::CondCodes)CC);
 224 }
 225
 226 // This function is used to sort the decls list.
 227 // should return true if s1 should come before s2.
 228 static bool is_before(const char *s1, const char *s2) {
 229   return strcmp(s1, s2) <= 0;
 230 }
 231
 232 // This is used by list::unique below.
 233 // unique will filter out duplicates if it knows them.
 234 static bool is_duplicate(const char *s1, const char *s2) {
 235   return !strcmp(s1, s2);
 236 }
 237
 238 /// printLibcallDecls - print the extern declarations for compiler
 239 /// intrinsics.
 240 ///
 241 void PIC16AsmPrinter::printLibcallDecls() {
 242   // If no libcalls used, return.
 243   if (LibcallDecls.empty()) return;
 244
 245   O << MAI->getCommentString() << "External decls for libcalls - BEGIN." <<"\n";
 246   // Remove duplicate entries.
 247   LibcallDecls.sort(is_before);
 248   LibcallDecls.unique(is_duplicate);
 249
 250   for (std::list<const char*>::const_iterator I = LibcallDecls.begin();
 251        I != LibcallDecls.end(); I++) {
 252     O << MAI->getExternDirective() << *I << "\n";
 253     O << MAI->getExternDirective() << PAN::getArgsLabel(*I) << "\n";
 254     O << MAI->getExternDirective() << PAN::getRetvalLabel(*I) << "\n";
 255   }
 256   O << MAI->getCommentString() << "External decls for libcalls - END." <<"\n";
 257 }
 258
 259 /// doInitialization - Perform Module level initializations here.
 260 /// One task that we do here is to sectionize all global variables.
 261 /// The MemSelOptimizer pass depends on the sectionizing.
 262 ///
 263 bool PIC16AsmPrinter::doInitialization(Module &M) {
 264   bool Result = AsmPrinter::doInitialization(M);
 265
 266   // FIXME:: This is temporary solution to generate the include file.
 267   // The processor should be passed to llc as in input and the header file
 268   // should be generated accordingly.
 269   O << "\n\t#include P16F1937.INC\n";
 270
 271   // Set the section names for all globals.
 272   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 273        I != E; ++I) {
 274
 275     // Record External Var Decls.
 276     if (I->isDeclaration()) {
 277       ExternalVarDecls.push_back(I);
 278       continue;
 279     }
 280
 281     // Record Exteranl Var Defs.
 282     if (I->hasExternalLinkage() || I->hasCommonLinkage()) {
 283       ExternalVarDefs.push_back(I);
 284     }
 285
 286     // Sectionify actual data.
 287     if (!I->hasAvailableExternallyLinkage()) {
 288       const MCSection *S = getObjFileLowering().SectionForGlobal(I, Mang, TM);
 289
 290       I->setSection(((const PIC16Section *)S)->getName());
 291     }
 292   }
 293
 294   DbgInfo.BeginModule(M);
 295   EmitFunctionDecls(M);
 296   EmitUndefinedVars(M);
 297   EmitDefinedVars(M);
 298   EmitIData(M);
 299   EmitUData(M);
 300   EmitRomData(M);
 301   EmitSharedUdata(M);
 302   EmitUserSections(M);
 303   return Result;
 304 }
 305
 306 /// Emit extern decls for functions imported from other modules, and emit
 307 /// global declarations for function defined in this module and which are
 308 /// available to other modules.
 309 ///
 310 void PIC16AsmPrinter::EmitFunctionDecls(Module &M) {
 311  // Emit declarations for external functions.
 312   O <<"\n"<<MAI->getCommentString() << "Function Declarations - BEGIN." <<"\n";
 313   for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
 314     if (I->isIntrinsic())
 315       continue;
 316
 317     std::string Name = Mang->getMangledName(I);
 318     if (Name.compare("@abort") == 0)
 319       continue;
 320
 321     if (!I->isDeclaration() && !I->hasExternalLinkage())
 322       continue;
 323
 324     // Do not emit memcpy, memset, and memmove here.
 325     // Calls to these routines can be generated in two ways,
 326     // 1. User calling the standard lib function
 327     // 2. Codegen generating these calls for llvm intrinsics.
 328     // In the first case a prototype is alread availale, while in
 329     // second case the call is via and externalsym and the prototype is missing.
 330     // So declarations for these are currently always getting printing by
 331     // tracking both kind of references in printInstrunction.
 332     if (I->isDeclaration() && PAN::isMemIntrinsic(Name)) continue;
 333
 334     const char *directive = I->isDeclaration() ? MAI->getExternDirective() :
 335                                                  MAI->getGlobalDirective();
 336
 337     O << directive << Name << "\n";
 338     O << directive << PAN::getRetvalLabel(Name) << "\n";
 339     O << directive << PAN::getArgsLabel(Name) << "\n";
 340   }
 341
 342   O << MAI->getCommentString() << "Function Declarations - END." <<"\n";
 343 }
 344
 345 // Emit variables imported from other Modules.
 346 void PIC16AsmPrinter::EmitUndefinedVars(Module &M) {
 347   std::vector<const GlobalVariable*> Items = ExternalVarDecls;
 348   if (!Items.size()) return;
 349
 350   O << "\n" << MAI->getCommentString() << "Imported Variables - BEGIN" << "\n";
 351   for (unsigned j = 0; j < Items.size(); j++) {
 352     O << MAI->getExternDirective() << Mang->getMangledName(Items[j]) << "\n";
 353   }
 354   O << MAI->getCommentString() << "Imported Variables - END" << "\n";
 355 }
 356
 357 // Emit variables defined in this module and are available to other modules.
 358 void PIC16AsmPrinter::EmitDefinedVars(Module &M) {
 359   std::vector<const GlobalVariable*> Items = ExternalVarDefs;
 360   if (!Items.size()) return;
 361
 362   O << "\n" << MAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
 363   for (unsigned j = 0; j < Items.size(); j++) {
 364     O << MAI->getGlobalDirective() << Mang->getMangledName(Items[j]) << "\n";
 365   }
 366   O <<  MAI->getCommentString() << "Exported Variables - END" << "\n";
 367 }
 368
 369 // Emit initialized data placed in ROM.
 370 void PIC16AsmPrinter::EmitRomData(Module &M) {
 371   EmitSingleSection(PTOF->ROMDATASection());
 372 }
 373
 374 // Emit Shared section udata.
 375 void PIC16AsmPrinter::EmitSharedUdata(Module &M) {
 376   EmitSingleSection(PTOF->SHAREDUDATASection());
 377 }
 378
 379 bool PIC16AsmPrinter::doFinalization(Module &M) {
 380   EmitAllAutos(M);
 381   printLibcallDecls();
 382   DbgInfo.EndModule(M);
 383   O << "\n\t" << "END\n";
 384   return AsmPrinter::doFinalization(M);
 385 }
 386
 387 void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
 388   const Function *F = MF.getFunction();
 389   std::string FuncName = Mang->getMangledName(F);
 390   const TargetData *TD = TM.getTargetData();
 391   // Emit the data section name.
 392   O << "\n";
 393
 394   PIC16Section *fPDataSection = const_cast<PIC16Section *>(getObjFileLowering().
 395                                 SectionForFrame(CurrentFnName));
 396
 397   fPDataSection->setColor(getFunctionColor(F));
 398   OutStreamer.SwitchSection(fPDataSection);
 399
 400   // Emit function frame label
 401   O << PAN::getFrameLabel(CurrentFnName) << ":\n";
 402
 403   const Type *RetType = F->getReturnType();
 404   unsigned RetSize = 0;
 405   if (RetType->getTypeID() != Type::VoidTyID)
 406     RetSize = TD->getTypeAllocSize(RetType);
 407
 408   //Emit function return value space
 409   // FIXME: Do not emit RetvalLable when retsize is zero. To do this
 410   // we will need to avoid printing a global directive for Retval label
 411   // in emitExternandGloblas.
 412   if(RetSize > 0)
 413      O << PAN::getRetvalLabel(CurrentFnName) << " RES " << RetSize << "\n";
 414   else
 415      O << PAN::getRetvalLabel(CurrentFnName) << ": \n";
 416
 417   // Emit variable to hold the space for function arguments
 418   unsigned ArgSize = 0;
 419   for (Function::const_arg_iterator argi = F->arg_begin(),
 420            arge = F->arg_end(); argi != arge ; ++argi) {
 421     const Type *Ty = argi->getType();
 422     ArgSize += TD->getTypeAllocSize(Ty);
 423    }
 424
 425   O << PAN::getArgsLabel(CurrentFnName) << " RES " << ArgSize << "\n";
 426
 427   // Emit temporary space
 428   int TempSize = PTLI->GetTmpSize();
 429   if (TempSize > 0)
 430     O << PAN::getTempdataLabel(CurrentFnName) << " RES  " << TempSize << '\n';
 431 }
 432
 433
 434 void PIC16AsmPrinter::EmitInitializedDataSection(const PIC16Section *S) {
 435   /// Emit Section header.
 436   OutStreamer.SwitchSection(S);
 437
 438     std::vector<const GlobalVariable*> Items = S->Items;
 439     for (unsigned j = 0; j < Items.size(); j++) {
 440       std::string Name = Mang->getMangledName(Items[j]);
 441       Constant *C = Items[j]->getInitializer();
 442       int AddrSpace = Items[j]->getType()->getAddressSpace();
 443       O << Name;
 444       EmitGlobalConstant(C, AddrSpace);
 445    }
 446 }
 447
 448 // Print all IDATA sections.
 449 void PIC16AsmPrinter::EmitIData(Module &M) {
 450   EmitSectionList (M, PTOF->IDATASections());
 451 }
 452
 453 void PIC16AsmPrinter::
 454 EmitUninitializedDataSection(const PIC16Section *S) {
 455     const TargetData *TD = TM.getTargetData();
 456     OutStreamer.SwitchSection(S);
 457     std::vector<const GlobalVariable*> Items = S->Items;
 458     for (unsigned j = 0; j < Items.size(); j++) {
 459       std::string Name = Mang->getMangledName(Items[j]);
 460       Constant *C = Items[j]->getInitializer();
 461       const Type *Ty = C->getType();
 462       unsigned Size = TD->getTypeAllocSize(Ty);
 463       O << Name << " RES " << Size << "\n";
 464     }
 465 }
 466
 467 // Print all UDATA sections.
 468 void PIC16AsmPrinter::EmitUData(Module &M) {
 469   EmitSectionList (M, PTOF->UDATASections());
 470 }
 471
 472 // Print all USER sections.
 473 void PIC16AsmPrinter::EmitUserSections(Module &M) {
 474   EmitSectionList (M, PTOF->USERSections());
 475 }
 476
 477 // Print all AUTO sections.
 478 void PIC16AsmPrinter::EmitAllAutos(Module &M) {
 479   EmitSectionList (M, PTOF->AUTOSections());
 480 }
 481
 482 extern "C" void LLVMInitializePIC16AsmPrinter() {
 483   RegisterAsmPrinter<PIC16AsmPrinter> X(ThePIC16Target);
 484 }
 485
 486 // Emit one data section using correct section emitter based on section type.
 487 void PIC16AsmPrinter::EmitSingleSection(const PIC16Section *S) {
 488   if (S == NULL) return;
 489
 490   switch (S->getType()) {
 491     default: llvm_unreachable ("unknow user section type");
 492     case UDATA:
 493     case UDATA_SHR:
 494     case UDATA_OVR:
 495       EmitUninitializedDataSection(S);
 496       break;
 497     case IDATA:
 498     case ROMDATA:
 499       EmitInitializedDataSection(S);
 500       break;
 501   }
 502 }
 503
 504 // Emit a list of sections.
 505 void PIC16AsmPrinter::
 506 EmitSectionList(Module &M, const std::vector<PIC16Section *> &SList) {
 507   for (unsigned i = 0; i < SList.size(); i++) {
 508     // Exclude llvm specific metadata sections.
 509     if (SList[i]->getName().find("llvm.") != std::string::npos)
 510       continue;
 511     O << "\n";
 512     EmitSingleSection(SList[i]);
 513   }
 514 }
 515