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       {
 174         // For indirect load/store insns, the fsr name is printed as INDF.
 175         std::string RegName = getRegisterName(MO.getReg());
 176         if ((MI->getOpcode() == PIC16::load_indirect) ||
 177             (MI->getOpcode() == PIC16::store_indirect))
 178         {
 179           RegName.replace (0, 3, "INDF");
 180         }
 181         O << RegName;
 182       }
 183       return;
 184
 185     case MachineOperand::MO_Immediate:
 186       O << (int)MO.getImm();
 187       return;
 188
 189     case MachineOperand::MO_GlobalAddress: {
 190       std::string Sname = Mang->getMangledName(MO.getGlobal());
 191       // FIXME: currently we do not have a memcpy def coming in the module
 192       // by any chance, as we do not link in those as .bc lib. So these calls
 193       // are always external and it is safe to emit an extern.
 194       if (PAN::isMemIntrinsic(Sname)) {
 195         LibcallDecls.push_back(createESName(Sname));
 196       }
 197
 198       O << Sname;
 199       break;
 200     }
 201     case MachineOperand::MO_ExternalSymbol: {
 202        const char *Sname = MO.getSymbolName();
 203
 204       // If its a libcall name, record it to decls section.
 205       if (PAN::getSymbolTag(Sname) == PAN::LIBCALL) {
 206         LibcallDecls.push_back(Sname);
 207       }
 208
 209       // Record a call to intrinsic to print the extern declaration for it.
 210       std::string Sym = Sname;
 211       if (PAN::isMemIntrinsic(Sym)) {
 212         Sym = PAN::addPrefix(Sym);
 213         LibcallDecls.push_back(createESName(Sym));
 214       }
 215
 216       O  << Sym;
 217       break;
 218     }
 219     case MachineOperand::MO_MachineBasicBlock:
 220       GetMBBSymbol(MO.getMBB()->getNumber())->print(O, MAI);
 221       return;
 222
 223     default:
 224       llvm_unreachable(" Operand type not supported.");
 225   }
 226 }
 227
 228 /// printCCOperand - Print the cond code operand.
 229 ///
 230 void PIC16AsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) {
 231   int CC = (int)MI->getOperand(opNum).getImm();
 232   O << PIC16CondCodeToString((PIC16CC::CondCodes)CC);
 233 }
 234
 235 // This function is used to sort the decls list.
 236 // should return true if s1 should come before s2.
 237 static bool is_before(const char *s1, const char *s2) {
 238   return strcmp(s1, s2) <= 0;
 239 }
 240
 241 // This is used by list::unique below.
 242 // unique will filter out duplicates if it knows them.
 243 static bool is_duplicate(const char *s1, const char *s2) {
 244   return !strcmp(s1, s2);
 245 }
 246
 247 /// printLibcallDecls - print the extern declarations for compiler
 248 /// intrinsics.
 249 ///
 250 void PIC16AsmPrinter::printLibcallDecls() {
 251   // If no libcalls used, return.
 252   if (LibcallDecls.empty()) return;
 253
 254   O << MAI->getCommentString() << "External decls for libcalls - BEGIN." <<"\n";
 255   // Remove duplicate entries.
 256   LibcallDecls.sort(is_before);
 257   LibcallDecls.unique(is_duplicate);
 258
 259   for (std::list<const char*>::const_iterator I = LibcallDecls.begin();
 260        I != LibcallDecls.end(); I++) {
 261     O << MAI->getExternDirective() << *I << "\n";
 262     O << MAI->getExternDirective() << PAN::getArgsLabel(*I) << "\n";
 263     O << MAI->getExternDirective() << PAN::getRetvalLabel(*I) << "\n";
 264   }
 265   O << MAI->getCommentString() << "External decls for libcalls - END." <<"\n";
 266 }
 267
 268 /// doInitialization - Perform Module level initializations here.
 269 /// One task that we do here is to sectionize all global variables.
 270 /// The MemSelOptimizer pass depends on the sectionizing.
 271 ///
 272 bool PIC16AsmPrinter::doInitialization(Module &M) {
 273   bool Result = AsmPrinter::doInitialization(M);
 274
 275   // Every asmbly contains these std headers.
 276   O << "\n#include p16f1xxx.inc";
 277   O << "\n#include stdmacros.inc";
 278
 279   // Set the section names for all globals.
 280   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 281        I != E; ++I) {
 282
 283     // Record External Var Decls.
 284     if (I->isDeclaration()) {
 285       ExternalVarDecls.push_back(I);
 286       continue;
 287     }
 288
 289     // Record Exteranl Var Defs.
 290     if (I->hasExternalLinkage() || I->hasCommonLinkage()) {
 291       ExternalVarDefs.push_back(I);
 292     }
 293
 294     // Sectionify actual data.
 295     if (!I->hasAvailableExternallyLinkage()) {
 296       const MCSection *S = getObjFileLowering().SectionForGlobal(I, Mang, TM);
 297
 298       I->setSection(((const PIC16Section *)S)->getName());
 299     }
 300   }
 301
 302   DbgInfo.BeginModule(M);
 303   EmitFunctionDecls(M);
 304   EmitUndefinedVars(M);
 305   EmitDefinedVars(M);
 306   EmitIData(M);
 307   EmitUData(M);
 308   EmitRomData(M);
 309   EmitSharedUdata(M);
 310   EmitUserSections(M);
 311   return Result;
 312 }
 313
 314 /// Emit extern decls for functions imported from other modules, and emit
 315 /// global declarations for function defined in this module and which are
 316 /// available to other modules.
 317 ///
 318 void PIC16AsmPrinter::EmitFunctionDecls(Module &M) {
 319  // Emit declarations for external functions.
 320   O <<"\n"<<MAI->getCommentString() << "Function Declarations - BEGIN." <<"\n";
 321   for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
 322     if (I->isIntrinsic())
 323       continue;
 324
 325     std::string Name = Mang->getMangledName(I);
 326     if (Name.compare("@abort") == 0)
 327       continue;
 328
 329     if (!I->isDeclaration() && !I->hasExternalLinkage())
 330       continue;
 331
 332     // Do not emit memcpy, memset, and memmove here.
 333     // Calls to these routines can be generated in two ways,
 334     // 1. User calling the standard lib function
 335     // 2. Codegen generating these calls for llvm intrinsics.
 336     // In the first case a prototype is alread availale, while in
 337     // second case the call is via and externalsym and the prototype is missing.
 338     // So declarations for these are currently always getting printing by
 339     // tracking both kind of references in printInstrunction.
 340     if (I->isDeclaration() && PAN::isMemIntrinsic(Name)) continue;
 341
 342     const char *directive = I->isDeclaration() ? MAI->getExternDirective() :
 343                                                  MAI->getGlobalDirective();
 344
 345     O << directive << Name << "\n";
 346     O << directive << PAN::getRetvalLabel(Name) << "\n";
 347     O << directive << PAN::getArgsLabel(Name) << "\n";
 348   }
 349
 350   O << MAI->getCommentString() << "Function Declarations - END." <<"\n";
 351 }
 352
 353 // Emit variables imported from other Modules.
 354 void PIC16AsmPrinter::EmitUndefinedVars(Module &M) {
 355   std::vector<const GlobalVariable*> Items = ExternalVarDecls;
 356   if (!Items.size()) return;
 357
 358   O << "\n" << MAI->getCommentString() << "Imported Variables - BEGIN" << "\n";
 359   for (unsigned j = 0; j < Items.size(); j++) {
 360     O << MAI->getExternDirective() << Mang->getMangledName(Items[j]) << "\n";
 361   }
 362   O << MAI->getCommentString() << "Imported Variables - END" << "\n";
 363 }
 364
 365 // Emit variables defined in this module and are available to other modules.
 366 void PIC16AsmPrinter::EmitDefinedVars(Module &M) {
 367   std::vector<const GlobalVariable*> Items = ExternalVarDefs;
 368   if (!Items.size()) return;
 369
 370   O << "\n" << MAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
 371   for (unsigned j = 0; j < Items.size(); j++) {
 372     O << MAI->getGlobalDirective() << Mang->getMangledName(Items[j]) << "\n";
 373   }
 374   O <<  MAI->getCommentString() << "Exported Variables - END" << "\n";
 375 }
 376
 377 // Emit initialized data placed in ROM.
 378 void PIC16AsmPrinter::EmitRomData(Module &M) {
 379   EmitSingleSection(PTOF->ROMDATASection());
 380 }
 381
 382 // Emit Shared section udata.
 383 void PIC16AsmPrinter::EmitSharedUdata(Module &M) {
 384   EmitSingleSection(PTOF->SHAREDUDATASection());
 385 }
 386
 387 bool PIC16AsmPrinter::doFinalization(Module &M) {
 388   EmitAllAutos(M);
 389   printLibcallDecls();
 390   DbgInfo.EndModule(M);
 391   O << "\n\t" << "END\n";
 392   return AsmPrinter::doFinalization(M);
 393 }
 394
 395 void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
 396   const Function *F = MF.getFunction();
 397   std::string FuncName = Mang->getMangledName(F);
 398   const TargetData *TD = TM.getTargetData();
 399   // Emit the data section name.
 400   O << "\n";
 401
 402   PIC16Section *fPDataSection = const_cast<PIC16Section *>(getObjFileLowering().
 403                                 SectionForFrame(CurrentFnName));
 404
 405   fPDataSection->setColor(getFunctionColor(F));
 406   OutStreamer.SwitchSection(fPDataSection);
 407
 408   // Emit function frame label
 409   O << PAN::getFrameLabel(CurrentFnName) << ":\n";
 410
 411   const Type *RetType = F->getReturnType();
 412   unsigned RetSize = 0;
 413   if (RetType->getTypeID() != Type::VoidTyID)
 414     RetSize = TD->getTypeAllocSize(RetType);
 415
 416   //Emit function return value space
 417   // FIXME: Do not emit RetvalLable when retsize is zero. To do this
 418   // we will need to avoid printing a global directive for Retval label
 419   // in emitExternandGloblas.
 420   if(RetSize > 0)
 421      O << PAN::getRetvalLabel(CurrentFnName) << " RES " << RetSize << "\n";
 422   else
 423      O << PAN::getRetvalLabel(CurrentFnName) << ": \n";
 424
 425   // Emit variable to hold the space for function arguments
 426   unsigned ArgSize = 0;
 427   for (Function::const_arg_iterator argi = F->arg_begin(),
 428            arge = F->arg_end(); argi != arge ; ++argi) {
 429     const Type *Ty = argi->getType();
 430     ArgSize += TD->getTypeAllocSize(Ty);
 431    }
 432
 433   O << PAN::getArgsLabel(CurrentFnName) << " RES " << ArgSize << "\n";
 434
 435   // Emit temporary space
 436   int TempSize = PTLI->GetTmpSize();
 437   if (TempSize > 0)
 438     O << PAN::getTempdataLabel(CurrentFnName) << " RES  " << TempSize << '\n';
 439 }
 440
 441
 442 void PIC16AsmPrinter::EmitInitializedDataSection(const PIC16Section *S) {
 443   /// Emit Section header.
 444   OutStreamer.SwitchSection(S);
 445
 446     std::vector<const GlobalVariable*> Items = S->Items;
 447     for (unsigned j = 0; j < Items.size(); j++) {
 448       std::string Name = Mang->getMangledName(Items[j]);
 449       Constant *C = Items[j]->getInitializer();
 450       int AddrSpace = Items[j]->getType()->getAddressSpace();
 451       O << Name;
 452       EmitGlobalConstant(C, AddrSpace);
 453    }
 454 }
 455
 456 // Print all IDATA sections.
 457 void PIC16AsmPrinter::EmitIData(Module &M) {
 458   EmitSectionList (M, PTOF->IDATASections());
 459 }
 460
 461 void PIC16AsmPrinter::
 462 EmitUninitializedDataSection(const PIC16Section *S) {
 463     const TargetData *TD = TM.getTargetData();
 464     OutStreamer.SwitchSection(S);
 465     std::vector<const GlobalVariable*> Items = S->Items;
 466     for (unsigned j = 0; j < Items.size(); j++) {
 467       std::string Name = Mang->getMangledName(Items[j]);
 468       Constant *C = Items[j]->getInitializer();
 469       const Type *Ty = C->getType();
 470       unsigned Size = TD->getTypeAllocSize(Ty);
 471       O << Name << " RES " << Size << "\n";
 472     }
 473 }
 474
 475 // Print all UDATA sections.
 476 void PIC16AsmPrinter::EmitUData(Module &M) {
 477   EmitSectionList (M, PTOF->UDATASections());
 478 }
 479
 480 // Print all USER sections.
 481 void PIC16AsmPrinter::EmitUserSections(Module &M) {
 482   EmitSectionList (M, PTOF->USERSections());
 483 }
 484
 485 // Print all AUTO sections.
 486 void PIC16AsmPrinter::EmitAllAutos(Module &M) {
 487   EmitSectionList (M, PTOF->AUTOSections());
 488 }
 489
 490 extern "C" void LLVMInitializePIC16AsmPrinter() {
 491   RegisterAsmPrinter<PIC16AsmPrinter> X(ThePIC16Target);
 492 }
 493
 494 // Emit one data section using correct section emitter based on section type.
 495 void PIC16AsmPrinter::EmitSingleSection(const PIC16Section *S) {
 496   if (S == NULL) return;
 497
 498   switch (S->getType()) {
 499     default: llvm_unreachable ("unknow user section type");
 500     case UDATA:
 501     case UDATA_SHR:
 502     case UDATA_OVR:
 503       EmitUninitializedDataSection(S);
 504       break;
 505     case IDATA:
 506     case ROMDATA:
 507       EmitInitializedDataSection(S);
 508       break;
 509   }
 510 }
 511
 512 // Emit a list of sections.
 513 void PIC16AsmPrinter::
 514 EmitSectionList(Module &M, const std::vector<PIC16Section *> &SList) {
 515   for (unsigned i = 0; i < SList.size(); i++) {
 516     // Exclude llvm specific metadata sections.
 517     if (SList[i]->getName().find("llvm.") != std::string::npos)
 518       continue;
 519     O << "\n";
 520     EmitSingleSection(SList[i]);
 521   }
 522 }
 523