lib/Target/PIC16/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 "PIC16AsmPrinter.h"
  16 #include "PIC16TargetAsmInfo.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/CodeGen/DwarfWriter.h"
  21 #include "llvm/CodeGen/MachineFrameInfo.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include "llvm/Support/Mangler.h"
  24 #include "llvm/CodeGen/DwarfWriter.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26
  27 using namespace llvm;
  28
  29 #include "PIC16GenAsmWriter.inc"
  30
  31 inline static bool isLocalToFunc (std::string &FuncName, std::string &VarName) {
  32   if (VarName.find(FuncName + ".auto.") != std::string::npos
  33       || VarName.find(FuncName + ".arg.") != std::string::npos)
  34     return true;
  35
  36   return false;
  37 }
  38
  39 inline static bool isLocalName (std::string &Name) {
  40   if (Name.find(".auto.") != std::string::npos
  41       || Name.find(".arg.") != std::string::npos)
  42     return true;
  43
  44   return false;
  45 }
  46
  47 bool PIC16AsmPrinter::printMachineInstruction(const MachineInstr *MI) {
  48   std::string NewBank = "";
  49   unsigned Operands = MI->getNumOperands();
  50   if (Operands > 1) {
  51     // Global address or external symbol should be second operand from last
  52     // if we want to print banksel for it.
  53     unsigned BankSelVar = Operands - 2;
  54     // In cases where an instruction has a def or use defined in td file,
  55     // that def or use becomes a machine instruction operand.
  56     // eg. addfw_1 instruction defines STATUS register. So the machine
  57     // instruction for it has MO_Register Operand as its last operand.
  58     while ((MI->getOperand(BankSelVar + 1).getType() ==
  59            MachineOperand::MO_Register) && (BankSelVar > 0))
  60      BankSelVar--;
  61     const MachineOperand &Op = MI->getOperand(BankSelVar);
  62     unsigned OpType = Op.getType();
  63     if (OpType == MachineOperand::MO_GlobalAddress ||
  64         OpType == MachineOperand::MO_ExternalSymbol) {
  65       if (OpType == MachineOperand::MO_GlobalAddress )
  66         NewBank = Op.getGlobal()->getSection();
  67       else {
  68         // External Symbol is generated for temp data. Temp data in in
  69         // fdata.<functionname>.# section.
  70         NewBank = "fpdata." + CurrentFnName +".#";
  71       }
  72       // Operand after global address or external symbol should be  banksel.
  73       // Value 1 for this operand means we need to generate banksel else do not
  74       // generate banksel.
  75       const MachineOperand &BS = MI->getOperand(BankSelVar+1);
  76       // If Section names are same then the variables are in same section.
  77       // This is not true for external variables as section names for global
  78       // variables in all files are same at this time. For eg. initialized
  79       // data in put in idata.# section in all files.
  80       if ((BS.getType() == MachineOperand::MO_Immediate
  81            && (int)BS.getImm() == 1)
  82           && ((Op.isGlobal() && Op.getGlobal()->hasExternalLinkage()) ||
  83            (NewBank.compare(CurBank) != 0))) {
  84         O << "\tbanksel ";
  85         printOperand(MI, BankSelVar);
  86         O << "\n";
  87         CurBank = NewBank;
  88       }
  89     }
  90   }
  91   printInstruction(MI);
  92   return true;
  93 }
  94
  95 /// runOnMachineFunction - This uses the printInstruction()
  96 /// method to print assembly for each instruction.
  97 ///
  98 bool PIC16AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
  99   this->MF = &MF;
 100
 101   // This calls the base class function required to be called at beginning
 102   // of runOnMachineFunction.
 103   SetupMachineFunction(MF);
 104
 105   // Get the mangled name.
 106   const Function *F = MF.getFunction();
 107   CurrentFnName = Mang->getValueName(F);
 108
 109   // Emit the function variables.
 110   emitFunctionData(MF);
 111   std::string codeSection;
 112   codeSection = "code." + CurrentFnName + ".# " + "CODE";
 113   const Section *fCodeSection = TAI->getNamedSection(codeSection.c_str(),
 114                                                SectionFlags::Code);
 115   O <<  "\n";
 116   SwitchToSection (fCodeSection);
 117
 118   // Emit the frame address of the function at the beginning of code.
 119   O << CurrentFnName << ":\n";
 120   O << "    retlw  low(" << FunctionLabelBegin<< CurrentFnName << ".frame)\n";
 121   O << "    retlw  high(" << FunctionLabelBegin<< CurrentFnName << ".frame)\n";
 122
 123
 124   // Print out code for the function.
 125   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 126        I != E; ++I) {
 127     // Print a label for the basic block.
 128     if (I != MF.begin()) {
 129       printBasicBlockLabel(I, true);
 130       O << '\n';
 131     }
 132     CurBank = "";
 133
 134     // For emitting line directives, we need to keep track of the current
 135     // source line. When it changes then only emit the line directive.
 136     unsigned CurLine = 0;
 137     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 138          II != E; ++II) {
 139       // Emit the line directive if source line changed.
 140       const DebugLoc DL = II->getDebugLoc();
 141       if (!DL.isUnknown()) {
 142         unsigned line = MF.getDebugLocTuple(DL).Line;
 143         if (line != CurLine) {
 144           O << "\t.line " << line << "\n";
 145           CurLine = line;
 146         }
 147       }
 148       // Print the assembly for the instruction.
 149       printMachineInstruction(II);
 150     }
 151   }
 152   return false;  // we didn't modify anything.
 153 }
 154
 155 /// createPIC16CodePrinterPass - Returns a pass that prints the PIC16
 156 /// assembly code for a MachineFunction to the given output stream,
 157 /// using the given target machine description.  This should work
 158 /// regardless of whether the function is in SSA form.
 159 ///
 160 FunctionPass *llvm::createPIC16CodePrinterPass(raw_ostream &o,
 161                                                PIC16TargetMachine &tm,
 162                                                bool fast, bool verbose) {
 163   return new PIC16AsmPrinter(o, tm, tm.getTargetAsmInfo(), fast, verbose);
 164 }
 165
 166 void PIC16AsmPrinter::printOperand(const MachineInstr *MI, int opNum) {
 167   const MachineOperand &MO = MI->getOperand(opNum);
 168
 169   switch (MO.getType()) {
 170     case MachineOperand::MO_Register:
 171       if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()))
 172         O << TM.getRegisterInfo()->get(MO.getReg()).AsmName;
 173       else
 174         assert(0 && "not implemented");
 175         return;
 176
 177     case MachineOperand::MO_Immediate:
 178       O << (int)MO.getImm();
 179       return;
 180
 181     case MachineOperand::MO_GlobalAddress: {
 182       std::string Name = Mang->getValueName(MO.getGlobal());
 183       if (isLocalName(Name))
 184         O << FunctionLabelBegin << Mang->getValueName(MO.getGlobal());
 185       else
 186          O << Mang->getValueName(MO.getGlobal());
 187       break;
 188     }
 189     case MachineOperand::MO_ExternalSymbol: {
 190       std::string Name = MO.getSymbolName();
 191       if (Name.find("__intrinsics.") != std::string::npos)
 192         O  << MO.getSymbolName();
 193       else
 194         O << FunctionLabelBegin << MO.getSymbolName();
 195       break;
 196     }
 197     case MachineOperand::MO_MachineBasicBlock:
 198       printBasicBlockLabel(MO.getMBB());
 199       return;
 200
 201     default:
 202       assert(0 && " Operand type not supported.");
 203   }
 204 }
 205
 206 void PIC16AsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) {
 207   int CC = (int)MI->getOperand(opNum).getImm();
 208   O << PIC16CondCodeToString((PIC16CC::CondCodes)CC);
 209 }
 210
 211
 212 bool PIC16AsmPrinter::doInitialization (Module &M) {
 213   bool Result = AsmPrinter::doInitialization(M);
 214   // FIXME:: This is temporary solution to generate the include file.
 215   // The processor should be passed to llc as in input and the header file
 216   // should be generated accordingly.
 217   O << "\t#include P16F1937.INC\n";
 218   MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>();
 219   assert(MMI);
 220   DwarfWriter *DW = getAnalysisIfAvailable<DwarfWriter>();
 221   assert(DW && "Dwarf Writer is not available");
 222   DW->BeginModule(&M, MMI, O, this, TAI);
 223
 224   EmitExternsAndGlobals (M);
 225   EmitInitData (M);
 226   EmitUnInitData(M);
 227   EmitRomData(M);
 228   return Result;
 229 }
 230
 231 void PIC16AsmPrinter::EmitExternsAndGlobals (Module &M) {
 232  // Emit declarations for external functions.
 233   O << "section.0" <<"\n";
 234   for (Module::iterator I = M.begin(), E = M.end(); I != E; I++) {
 235     std::string Name = Mang->getValueName(I);
 236     if (Name.compare("abort") == 0)
 237       continue;
 238
 239     // If it is llvm intrinsic call then don't emit
 240     if (Name.find("llvm.") != std::string::npos)
 241       continue;
 242
 243     if (I->isDeclaration()) {
 244       O << "\textern " <<Name << "\n";
 245       O << "\textern "  << FunctionLabelBegin << Name << ".retval\n";
 246       O << "\textern " << FunctionLabelBegin << Name << ".args\n";
 247     }
 248     else if (I->hasExternalLinkage()) {
 249       O << "\tglobal " << Name << "\n";
 250       O << "\tglobal " << FunctionLabelBegin << Name << ".retval\n";
 251       O << "\tglobal " << FunctionLabelBegin<< Name << ".args\n";
 252     }
 253   }
 254
 255   // Emit header file to include declaration of library functions
 256   O << "\t#include C16IntrinsicCalls.INC\n";
 257
 258   // Emit declarations for external globals.
 259   for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
 260        I != E; I++) {
 261     // Any variables reaching here with ".auto." in its name is a local scope
 262     // variable and should not be printed in global data section.
 263     std::string Name = Mang->getValueName(I);
 264     if (isLocalName (Name))
 265       continue;
 266
 267     if (I->isDeclaration())
 268       O << "\textern "<< Name << "\n";
 269     else if (I->hasCommonLinkage() || I->hasExternalLinkage())
 270       O << "\tglobal "<< Name << "\n";
 271   }
 272 }
 273
 274 void PIC16AsmPrinter::EmitInitData (Module &M) {
 275   SwitchToSection(TAI->getDataSection());
 276   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 277        I != E; ++I) {
 278     if (!I->hasInitializer())   // External global require no code.
 279       continue;
 280
 281     Constant *C = I->getInitializer();
 282     const PointerType *PtrTy = I->getType();
 283     int AddrSpace = PtrTy->getAddressSpace();
 284
 285     if ((!C->isNullValue()) && (AddrSpace == PIC16ISD::RAM_SPACE)) {
 286
 287       if (EmitSpecialLLVMGlobal(I))
 288         continue;
 289
 290       // Any variables reaching here with "." in its name is a local scope
 291       // variable and should not be printed in global data section.
 292       std::string Name = Mang->getValueName(I);
 293       if (isLocalName(Name))
 294         continue;
 295
 296       I->setSection(TAI->getDataSection()->getName());
 297       O << Name;
 298       EmitGlobalConstant(C, AddrSpace);
 299     }
 300   }
 301 }
 302
 303 void PIC16AsmPrinter::EmitRomData (Module &M)
 304 {
 305   SwitchToSection(TAI->getReadOnlySection());
 306   IsRomData = true;
 307   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 308        I != E; ++I) {
 309     if (!I->hasInitializer())   // External global require no code.
 310       continue;
 311
 312     Constant *C = I->getInitializer();
 313     const PointerType *PtrTy = I->getType();
 314     int AddrSpace = PtrTy->getAddressSpace();
 315     if ((!C->isNullValue()) && (AddrSpace == PIC16ISD::ROM_SPACE)) {
 316
 317       if (EmitSpecialLLVMGlobal(I))
 318         continue;
 319
 320       // Any variables reaching here with "." in its name is a local scope
 321       // variable and should not be printed in global data section.
 322       std::string name = Mang->getValueName(I);
 323       if (name.find(".") != std::string::npos)
 324         continue;
 325
 326       I->setSection(TAI->getReadOnlySection()->getName());
 327       O << name;
 328       EmitGlobalConstant(C, AddrSpace);
 329       O << "\n";
 330     }
 331   }
 332   IsRomData = false;
 333 }
 334
 335 void PIC16AsmPrinter::EmitUnInitData (Module &M)
 336 {
 337   SwitchToSection(TAI->getBSSSection_());
 338   const TargetData *TD = TM.getTargetData();
 339
 340   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 341        I != E; ++I) {
 342     if (!I->hasInitializer())   // External global require no code.
 343       continue;
 344
 345     Constant *C = I->getInitializer();
 346     if (C->isNullValue()) {
 347
 348       if (EmitSpecialLLVMGlobal(I))
 349         continue;
 350
 351       // Any variables reaching here with "." in its name is a local scope
 352       // variable and should not be printed in global data section.
 353       std::string name = Mang->getValueName(I);
 354       if (name.find(".") != std::string::npos)
 355         continue;
 356
 357       I->setSection(TAI->getBSSSection_()->getName());
 358
 359       const Type *Ty = C->getType();
 360       unsigned Size = TD->getTypePaddedSize(Ty);
 361
 362       O << name << " " <<"RES"<< " " << Size ;
 363       O << "\n";
 364     }
 365   }
 366 }
 367
 368 bool PIC16AsmPrinter::doFinalization(Module &M) {
 369   O << "\t" << "END\n";
 370   bool Result = AsmPrinter::doFinalization(M);
 371   return Result;
 372 }
 373
 374 void PIC16AsmPrinter::emitFunctionData(MachineFunction &MF) {
 375   const Function *F = MF.getFunction();
 376   std::string FuncName = Mang->getValueName(F);
 377   Module *M = const_cast<Module *>(F->getParent());
 378   const TargetData *TD = TM.getTargetData();
 379   unsigned FrameSize = 0;
 380   // Emit the data section name.
 381   O << "\n";
 382   std::string SectionName = "fpdata." + CurrentFnName + ".# " + "UDATA_OVR";
 383
 384   const Section *fPDataSection = TAI->getNamedSection(SectionName.c_str(),
 385                                                       SectionFlags::Writeable);
 386   SwitchToSection(fPDataSection);
 387
 388
 389   // Emit function frame label
 390   O << FunctionLabelBegin << CurrentFnName << ".frame:\n";
 391
 392   const Type *RetType = F->getReturnType();
 393   unsigned RetSize = 0;
 394   if (RetType->getTypeID() != Type::VoidTyID)
 395     RetSize = TD->getTypePaddedSize(RetType);
 396
 397   //Emit function return value space
 398   if(RetSize > 0)
 399      O << FunctionLabelBegin << CurrentFnName << ".retval    RES  " << RetSize
 400        << "\n";
 401   else
 402      O << FunctionLabelBegin << CurrentFnName << ".retval:\n";
 403
 404   // Emit variable to hold the space for function arguments
 405   unsigned ArgSize = 0;
 406   for (Function::const_arg_iterator argi = F->arg_begin(),
 407            arge = F->arg_end(); argi != arge ; ++argi) {
 408     const Type *Ty = argi->getType();
 409     ArgSize += TD->getTypePaddedSize(Ty);
 410    }
 411   O << FunctionLabelBegin << CurrentFnName << ".args      RES  " << ArgSize
 412     << "\n";
 413
 414   // Emit temporary space
 415   int TempSize = PTLI->GetTmpSize();
 416   if (TempSize > 0 )
 417     O << FunctionLabelBegin << CurrentFnName << ".tmp       RES  " << TempSize
 418       <<"\n";
 419
 420   // Emit the section name for local variables.
 421   O << "\n";
 422   std::string SecNameLocals = "fadata." + CurrentFnName + ".# " + "UDATA_OVR";
 423
 424   const Section *fADataSection = TAI->getNamedSection(SecNameLocals.c_str(),
 425                                                       SectionFlags::Writeable);
 426   SwitchToSection(fADataSection);
 427
 428   // Emit the function variables.
 429
 430   // In PIC16 all the function arguments and local variables are global.
 431   // Therefore to get the variable belonging to this function entire
 432   // global list will be traversed and variables belonging to this function
 433   // will be emitted in the current data section.
 434   for (Module::global_iterator I = M->global_begin(), E = M->global_end();
 435        I != E; ++I) {
 436     std::string VarName = Mang->getValueName(I);
 437
 438     // The variables of a function are of form FuncName.* . If this variable
 439     // does not belong to this function then continue.
 440     // Static local varilabes of a function does not have .auto. in their
 441     // name. They are not printed as part of function data but module
 442     // level global data.
 443     if (! isLocalToFunc(FuncName, VarName))
 444      continue;
 445
 446     I->setSection("fadata." + CurrentFnName + ".#");
 447     Constant *C = I->getInitializer();
 448     const Type *Ty = C->getType();
 449     unsigned Size = TD->getTypePaddedSize(Ty);
 450     FrameSize += Size;
 451     // Emit memory reserve directive.
 452     O << FunctionLabelBegin << VarName << "  RES  " << Size << "\n";
 453   }
 454
 455 }