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 && !MI->getDebugLoc().isUnknown())
  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   EmitUserSections(M);
 302   return Result;
 303 }
 304
 305 /// Emit extern decls for functions imported from other modules, and emit
 306 /// global declarations for function defined in this module and which are
 307 /// available to other modules.
 308 ///
 309 void PIC16AsmPrinter::EmitFunctionDecls(Module &M) {
 310  // Emit declarations for external functions.
 311   O <<"\n"<<MAI->getCommentString() << "Function Declarations - BEGIN." <<"\n";
 312   for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
 313     if (I->isIntrinsic())
 314       continue;
 315
 316     std::string Name = Mang->getMangledName(I);
 317     if (Name.compare("@abort") == 0)
 318       continue;
 319
 320     if (!I->isDeclaration() && !I->hasExternalLinkage())
 321       continue;
 322
 323     // Do not emit memcpy, memset, and memmove here.
 324     // Calls to these routines can be generated in two ways,
 325     // 1. User calling the standard lib function
 326     // 2. Codegen generating these calls for llvm intrinsics.
 327     // In the first case a prototype is alread availale, while in
 328     // second case the call is via and externalsym and the prototype is missing.
 329     // So declarations for these are currently always getting printing by
 330     // tracking both kind of references in printInstrunction.
 331     if (I->isDeclaration() && PAN::isMemIntrinsic(Name)) continue;
 332
 333     const char *directive = I->isDeclaration() ? MAI->getExternDirective() :
 334                                                  MAI->getGlobalDirective();
 335
 336     O << directive << Name << "\n";
 337     O << directive << PAN::getRetvalLabel(Name) << "\n";
 338     O << directive << PAN::getArgsLabel(Name) << "\n";
 339   }
 340
 341   O << MAI->getCommentString() << "Function Declarations - END." <<"\n";
 342 }
 343
 344 // Emit variables imported from other Modules.
 345 void PIC16AsmPrinter::EmitUndefinedVars(Module &M) {
 346   std::vector<const GlobalVariable*> Items = ExternalVarDecls;
 347   if (!Items.size()) return;
 348
 349   O << "\n" << MAI->getCommentString() << "Imported Variables - BEGIN" << "\n";
 350   for (unsigned j = 0; j < Items.size(); j++) {
 351     O << MAI->getExternDirective() << Mang->getMangledName(Items[j]) << "\n";
 352   }
 353   O << MAI->getCommentString() << "Imported Variables - END" << "\n";
 354 }
 355
 356 // Emit variables defined in this module and are available to other modules.
 357 void PIC16AsmPrinter::EmitDefinedVars(Module &M) {
 358   std::vector<const GlobalVariable*> Items = ExternalVarDefs;
 359   if (!Items.size()) return;
 360
 361   O << "\n" << MAI->getCommentString() << "Exported Variables - BEGIN" << "\n";
 362   for (unsigned j = 0; j < Items.size(); j++) {
 363     O << MAI->getGlobalDirective() << Mang->getMangledName(Items[j]) << "\n";
 364   }
 365   O <<  MAI->getCommentString() << "Exported Variables - END" << "\n";
 366 }
 367
 368 // Emit initialized data placed in ROM.
 369 void PIC16AsmPrinter::EmitRomData(Module &M) {
 370   EmitSingleSection(PTOF->ROMDATASection());
 371 }
 372
 373 bool PIC16AsmPrinter::doFinalization(Module &M) {
 374   EmitAllAutos(M);
 375   printLibcallDecls();
 376   DbgInfo.EndModule(M);
 377   O << "\n\t" << "END\n";
 378   return AsmPrinter::doFinalization(M);
 379 }
 380
 381 void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
 382   const Function *F = MF.getFunction();
 383   std::string FuncName = Mang->getMangledName(F);
 384   const TargetData *TD = TM.getTargetData();
 385   // Emit the data section name.
 386   O << "\n";
 387
 388   PIC16Section *fPDataSection = const_cast<PIC16Section *>(getObjFileLowering().
 389                                 SectionForFrame(CurrentFnName));
 390
 391   fPDataSection->setColor(getFunctionColor(F));
 392   OutStreamer.SwitchSection(fPDataSection);
 393
 394   // Emit function frame label
 395   O << PAN::getFrameLabel(CurrentFnName) << ":\n";
 396
 397   const Type *RetType = F->getReturnType();
 398   unsigned RetSize = 0;
 399   if (RetType->getTypeID() != Type::VoidTyID)
 400     RetSize = TD->getTypeAllocSize(RetType);
 401
 402   //Emit function return value space
 403   // FIXME: Do not emit RetvalLable when retsize is zero. To do this
 404   // we will need to avoid printing a global directive for Retval label
 405   // in emitExternandGloblas.
 406   if(RetSize > 0)
 407      O << PAN::getRetvalLabel(CurrentFnName) << " RES " << RetSize << "\n";
 408   else
 409      O << PAN::getRetvalLabel(CurrentFnName) << ": \n";
 410
 411   // Emit variable to hold the space for function arguments
 412   unsigned ArgSize = 0;
 413   for (Function::const_arg_iterator argi = F->arg_begin(),
 414            arge = F->arg_end(); argi != arge ; ++argi) {
 415     const Type *Ty = argi->getType();
 416     ArgSize += TD->getTypeAllocSize(Ty);
 417    }
 418
 419   O << PAN::getArgsLabel(CurrentFnName) << " RES " << ArgSize << "\n";
 420
 421   // Emit temporary space
 422   int TempSize = PTLI->GetTmpSize();
 423   if (TempSize > 0)
 424     O << PAN::getTempdataLabel(CurrentFnName) << " RES  " << TempSize << '\n';
 425 }
 426
 427
 428 void PIC16AsmPrinter::EmitInitializedDataSection(const PIC16Section *S) {
 429   /// Emit Section header.
 430   OutStreamer.SwitchSection(S);
 431
 432     std::vector<const GlobalVariable*> Items = S->Items;
 433     for (unsigned j = 0; j < Items.size(); j++) {
 434       std::string Name = Mang->getMangledName(Items[j]);
 435       Constant *C = Items[j]->getInitializer();
 436       int AddrSpace = Items[j]->getType()->getAddressSpace();
 437       O << Name;
 438       EmitGlobalConstant(C, AddrSpace);
 439    }
 440 }
 441
 442 // Print all IDATA sections.
 443 void PIC16AsmPrinter::EmitIData(Module &M) {
 444   EmitSectionList (M, PTOF->IDATASections());
 445 }
 446
 447 void PIC16AsmPrinter::
 448 EmitUninitializedDataSection(const PIC16Section *S) {
 449     const TargetData *TD = TM.getTargetData();
 450     OutStreamer.SwitchSection(S);
 451     std::vector<const GlobalVariable*> Items = S->Items;
 452     for (unsigned j = 0; j < Items.size(); j++) {
 453       std::string Name = Mang->getMangledName(Items[j]);
 454       Constant *C = Items[j]->getInitializer();
 455       const Type *Ty = C->getType();
 456       unsigned Size = TD->getTypeAllocSize(Ty);
 457       O << Name << " RES " << Size << "\n";
 458     }
 459 }
 460
 461 // Print all UDATA sections.
 462 void PIC16AsmPrinter::EmitUData(Module &M) {
 463   EmitSectionList (M, PTOF->UDATASections());
 464 }
 465
 466 // Print all USER sections.
 467 void PIC16AsmPrinter::EmitUserSections(Module &M) {
 468   EmitSectionList (M, PTOF->USERSections());
 469 }
 470
 471 // Print all AUTO sections.
 472 void PIC16AsmPrinter::EmitAllAutos(Module &M) {
 473   EmitSectionList (M, PTOF->AUTOSections());
 474 }
 475
 476 extern "C" void LLVMInitializePIC16AsmPrinter() {
 477   RegisterAsmPrinter<PIC16AsmPrinter> X(ThePIC16Target);
 478 }
 479
 480 // Emit one data section using correct section emitter based on section type.
 481 void PIC16AsmPrinter::EmitSingleSection(const PIC16Section *S) {
 482   if (S == NULL) return;
 483
 484   switch (S->getType()) {
 485     default: llvm_unreachable ("unknow user section type");
 486     case UDATA:
 487     case UDATA_SHR:
 488     case UDATA_OVR:
 489       EmitUninitializedDataSection(S);
 490       break;
 491     case IDATA:
 492     case ROMDATA:
 493       EmitInitializedDataSection(S);
 494       break;
 495   }
 496 }
 497
 498 // Emit a list of sections.
 499 void PIC16AsmPrinter::
 500 EmitSectionList(Module &M, const std::vector<PIC16Section *> &SList) {
 501   for (unsigned i = 0; i < SList.size(); i++) {
 502     // Exclude llvm specific metadata sections.
 503     if (SList[i]->getName().find("llvm.") != std::string::npos)
 504       continue;
 505     O << "\n";
 506     EmitSingleSection(SList[i]);
 507   }
 508 }
 509