lib/Target/PIC16/PIC16DebugInfo.cpp

   1 //===-- PIC16DebugInfo.cpp - Implementation for PIC16 Debug Information ======//
   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 the helper functions for representing debug information.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PIC16.h"
  15 #include "PIC16DebugInfo.h"
  16 #include "llvm/GlobalVariable.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/Support/DebugLoc.h"
  19 #include "llvm/Support/raw_ostream.h"
  20
  21 using namespace llvm;
  22
  23 /// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
  24 ///
  25 void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
  26                                       bool &HasAux, int Aux[],
  27                                       std::string &TagName) {
  28   if (Ty.isBasicType(Ty.getTag()))
  29     PopulateBasicTypeInfo (Ty, TypeNo);
  30   else if (Ty.isDerivedType(Ty.getTag()))
  31     PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
  32   else if (Ty.isCompositeType(Ty.getTag()))
  33     PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
  34   else {
  35     TypeNo = PIC16Dbg::T_NULL;
  36     HasAux = false;
  37   }
  38   return;
  39 }
  40
  41 /// PopulateBasicTypeInfo- Populate TypeNo for basic type from Ty.
  42 ///
  43 void PIC16DbgInfo::PopulateBasicTypeInfo (DIType Ty, unsigned short &TypeNo) {
  44   std::string Name = "";
  45   Ty.getName(Name);
  46   unsigned short BaseTy = GetTypeDebugNumber(Name);
  47   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
  48   TypeNo = TypeNo | (0xffff & BaseTy);
  49 }
  50
  51 /// PopulateDerivedTypeInfo - Populate TypeNo, Aux[], TagName for derived type
  52 /// from Ty. Derived types are mostly pointers.
  53 ///
  54 void PIC16DbgInfo::PopulateDerivedTypeInfo (DIType Ty, unsigned short &TypeNo,
  55                                             bool &HasAux, int Aux[],
  56                                             std::string &TagName) {
  57
  58   switch(Ty.getTag())
  59   {
  60     case dwarf::DW_TAG_pointer_type:
  61       TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
  62       TypeNo = TypeNo | PIC16Dbg::DT_PTR;
  63       break;
  64     default:
  65       TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
  66   }
  67
  68   // We also need to encode the the information about the base type of
  69   // pointer in TypeNo.
  70   DIType BaseType = DIDerivedType(Ty.getGV()).getTypeDerivedFrom();
  71   PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
  72 }
  73
  74 /// PopulateArrayTypeInfo - Populate TypeNo, Aux[] for array from Ty.
  75 void PIC16DbgInfo::PopulateArrayTypeInfo (DIType Ty, unsigned short &TypeNo,
  76                                           bool &HasAux, int Aux[],
  77                                           std::string &TagName) {
  78
  79   DICompositeType CTy = DICompositeType(Ty.getGV());
  80   DIArray Elements = CTy.getTypeArray();
  81   unsigned short size = 1;
  82   unsigned short Dimension[4]={0,0,0,0};
  83   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
  84     DIDescriptor Element = Elements.getElement(i);
  85     if (Element.getTag() == dwarf::DW_TAG_subrange_type) {
  86       TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
  87       TypeNo = TypeNo | PIC16Dbg::DT_ARY;
  88       DISubrange SubRange = DISubrange(Element.getGV());
  89       Dimension[i] = SubRange.getHi() - SubRange.getLo() + 1;
  90       // Each dimension is represented by 2 bytes starting at byte 9.
  91       Aux[8+i*2+0] = Dimension[i];
  92       Aux[8+i*2+1] = Dimension[i] >> 8;
  93       size = size * Dimension[i];
  94     }
  95   }
  96   HasAux = true;
  97   // In auxillary entry for array, 7th and 8th byte represent array size.
  98   Aux[6] = size & 0xff;
  99   Aux[7] = size >> 8;
 100   DIType BaseType = CTy.getTypeDerivedFrom();
 101   PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
 102 }
 103
 104 /// PopulateStructOrUnionTypeInfo - Populate TypeNo, Aux[] , TagName for
 105 /// structure or union.
 106 ///
 107 void PIC16DbgInfo::PopulateStructOrUnionTypeInfo (DIType Ty,
 108                                                   unsigned short &TypeNo,
 109                                                   bool &HasAux, int Aux[],
 110                                                   std::string &TagName) {
 111   DICompositeType CTy = DICompositeType(Ty.getGV());
 112   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
 113   if (Ty.getTag() == dwarf::DW_TAG_structure_type)
 114     TypeNo = TypeNo | PIC16Dbg::T_STRUCT;
 115   else
 116     TypeNo = TypeNo | PIC16Dbg::T_UNION;
 117   CTy.getName(TagName);
 118   // UniqueSuffix is .number where number is obtained from
 119   // llvm.dbg.composite<number>.
 120   std::string UniqueSuffix = "." + Ty.getGV()->getName().substr(18);
 121   TagName += UniqueSuffix;
 122   unsigned short size = CTy.getSizeInBits()/8;
 123   // 7th and 8th byte represent size.
 124   HasAux = true;
 125   Aux[6] = size & 0xff;
 126   Aux[7] = size >> 8;
 127 }
 128
 129 /// PopulateEnumTypeInfo - Populate TypeNo for enum from Ty.
 130 void PIC16DbgInfo::PopulateEnumTypeInfo (DIType Ty, unsigned short &TypeNo) {
 131   TypeNo = TypeNo << PIC16Dbg::S_BASIC;
 132   TypeNo = TypeNo | PIC16Dbg::T_ENUM;
 133 }
 134
 135 /// PopulateCompositeTypeInfo - Populate TypeNo, Aux[] and TagName for
 136 /// composite types from Ty.
 137 ///
 138 void PIC16DbgInfo::PopulateCompositeTypeInfo (DIType Ty, unsigned short &TypeNo,
 139                                               bool &HasAux, int Aux[],
 140                                               std::string &TagName) {
 141   switch (Ty.getTag()) {
 142     case dwarf::DW_TAG_array_type: {
 143       PopulateArrayTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
 144       break;
 145     }
 146     case dwarf:: DW_TAG_union_type:
 147     case dwarf::DW_TAG_structure_type: {
 148       PopulateStructOrUnionTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
 149       break;
 150     }
 151     case dwarf::DW_TAG_enumeration_type: {
 152       PopulateEnumTypeInfo (Ty, TypeNo);
 153       break;
 154     }
 155     default:
 156       TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
 157   }
 158 }
 159
 160 /// GetTypeDebugNumber - Get debug type number for given type.
 161 ///
 162 unsigned PIC16DbgInfo::GetTypeDebugNumber(std::string &type)  {
 163   if (type == "char")
 164     return PIC16Dbg::T_CHAR;
 165   else if (type == "short")
 166     return PIC16Dbg::T_SHORT;
 167   else if (type == "int")
 168     return PIC16Dbg::T_INT;
 169   else if (type == "long")
 170     return PIC16Dbg::T_LONG;
 171   else if (type == "unsigned char")
 172     return PIC16Dbg::T_UCHAR;
 173   else if (type == "unsigned short")
 174     return PIC16Dbg::T_USHORT;
 175   else if (type == "unsigned int")
 176     return PIC16Dbg::T_UINT;
 177   else if (type == "unsigned long")
 178     return PIC16Dbg::T_ULONG;
 179   else
 180     return 0;
 181 }
 182
 183 /// GetStorageClass - Get storage class for give debug variable.
 184 ///
 185 short PIC16DbgInfo::getStorageClass(DIGlobalVariable DIGV) {
 186   short ClassNo;
 187   if (PAN::isLocalName(DIGV.getGlobal()->getName())) {
 188     // Generating C_AUTO here fails due to error in linker. Change it once
 189     // linker is fixed.
 190     ClassNo = PIC16Dbg::C_STAT;
 191   }
 192   else if (DIGV.isLocalToUnit())
 193     ClassNo = PIC16Dbg::C_STAT;
 194   else
 195     ClassNo = PIC16Dbg::C_EXT;
 196   return ClassNo;
 197 }
 198
 199 /// BeginModule - Emit necessary debug info to start a Module and do other
 200 /// required initializations.
 201 void PIC16DbgInfo::BeginModule(Module &M) {
 202   // Emit file directive for module.
 203   // FIXME : What if more then one CUs are present in a module ?
 204   GlobalVariable *CU = M.getNamedGlobal("llvm.dbg.compile_unit");
 205   if (CU) {
 206     EmitDebugDirectives = true;
 207     SwitchToCU(CU);
 208   }
 209
 210   // Emit debug info for decls of composite types.
 211   EmitCompositeTypeDecls(M);
 212 }
 213
 214 /// Helper to find first valid debug loc for a function.
 215 ///
 216 static const DebugLoc GetDebugLocForFunction(const MachineFunction &MF) {
 217   DebugLoc DL;
 218   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 219        I != E; ++I) {
 220     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 221          II != E; ++II) {
 222       DL = II->getDebugLoc();
 223       if (!DL.isUnknown())
 224         return DL;
 225     }
 226   }
 227   return DL;
 228 }
 229
 230 /// BeginFunction - Emit necessary debug info to start a function.
 231 ///
 232 void PIC16DbgInfo::BeginFunction(const MachineFunction &MF) {
 233   if (! EmitDebugDirectives) return;
 234
 235   // Retreive the first valid debug Loc and process it.
 236   const DebugLoc &DL = GetDebugLocForFunction(MF);
 237   ChangeDebugLoc(MF, DL, true);
 238
 239   EmitFunctBeginDI(MF.getFunction());
 240
 241   // Set current line to 0 so that.line directive is genearted after .bf.
 242   CurLine = 0;
 243 }
 244
 245 /// ChangeDebugLoc - Take necessary steps when DebugLoc changes.
 246 /// CurFile and CurLine may change as a result of this.
 247 ///
 248 void PIC16DbgInfo::ChangeDebugLoc(const MachineFunction &MF,
 249                                   const DebugLoc &DL, bool IsInBeginFunction) {
 250   if (! EmitDebugDirectives) return;
 251   assert (! DL.isUnknown()  && "can't change to invalid debug loc");
 252
 253   GlobalVariable *CU = MF.getDebugLocTuple(DL).CompileUnit;
 254   unsigned line = MF.getDebugLocTuple(DL).Line;
 255
 256   SwitchToCU(CU);
 257   SwitchToLine(line, IsInBeginFunction);
 258 }
 259
 260 /// SwitchToLine - Emit line directive for a new line.
 261 ///
 262 void PIC16DbgInfo::SwitchToLine(unsigned Line, bool IsInBeginFunction) {
 263   if (CurLine == Line) return;
 264   if (!IsInBeginFunction)  O << "\n\t.line " << Line << "\n";
 265   CurLine = Line;
 266 }
 267
 268 /// EndFunction - Emit .ef for end of function.
 269 ///
 270 void PIC16DbgInfo::EndFunction(const MachineFunction &MF) {
 271   if (! EmitDebugDirectives) return;
 272   EmitFunctEndDI(MF.getFunction(), CurLine);
 273 }
 274
 275 /// EndModule - Emit .eof for end of module.
 276 ///
 277 void PIC16DbgInfo::EndModule(Module &M) {
 278   if (! EmitDebugDirectives) return;
 279   EmitVarDebugInfo(M);
 280   if (CurFile != "") O << "\n\t.eof";
 281 }
 282
 283 /// EmitCompositeTypeElements - Emit debug information for members of a
 284 /// composite type.
 285 ///
 286 void PIC16DbgInfo::EmitCompositeTypeElements (DICompositeType CTy,
 287                                               std::string UniqueSuffix) {
 288   unsigned long Value = 0;
 289   DIArray Elements = CTy.getTypeArray();
 290   for (unsigned i = 0, N = Elements.getNumElements(); i < N; i++) {
 291     DIDescriptor Element = Elements.getElement(i);
 292     unsigned short TypeNo = 0;
 293     bool HasAux = false;
 294     int ElementAux[PIC16Dbg::AuxSize] = { 0 };
 295     std::string TagName = "";
 296     std::string ElementName;
 297     GlobalVariable *GV = Element.getGV();
 298     DIDerivedType DITy(GV);
 299     DITy.getName(ElementName);
 300     unsigned short ElementSize = DITy.getSizeInBits()/8;
 301     // Get mangleddd name for this structure/union  element.
 302     std::string MangMemName = ElementName + UniqueSuffix;
 303     PopulateDebugInfo(DITy, TypeNo, HasAux, ElementAux, TagName);
 304     short Class = 0;
 305     if( CTy.getTag() == dwarf::DW_TAG_union_type)
 306       Class = PIC16Dbg::C_MOU;
 307     else if  (CTy.getTag() == dwarf::DW_TAG_structure_type)
 308       Class = PIC16Dbg::C_MOS;
 309     EmitSymbol(MangMemName, Class, TypeNo, Value);
 310     if (CTy.getTag() == dwarf::DW_TAG_structure_type)
 311       Value += ElementSize;
 312     if (HasAux)
 313       EmitAuxEntry(MangMemName, ElementAux, PIC16Dbg::AuxSize, TagName);
 314   }
 315 }
 316
 317 /// EmitCompositeTypeDecls - Emit composite type declarations like structure
 318 /// and union declarations.
 319 ///
 320 void PIC16DbgInfo::EmitCompositeTypeDecls(Module &M) {
 321   for(iplist<GlobalVariable>::iterator I = M.getGlobalList().begin(),
 322       E = M.getGlobalList().end(); I != E; I++) {
 323     // Structures and union declaration's debug info has llvm.dbg.composite
 324     // in its name.
 325     // FIXME: Checking and relying on llvm.dbg.composite name is not a good idea.
 326     if(I->getName().find("llvm.dbg.composite") != std::string::npos) {
 327       GlobalVariable *GV = cast<GlobalVariable >(I);
 328       DICompositeType CTy(GV);
 329       if (CTy.getTag() == dwarf::DW_TAG_union_type ||
 330           CTy.getTag() == dwarf::DW_TAG_structure_type ) {
 331         std::string name;
 332         CTy.getName(name);
 333         std::string DIVar = I->getName();
 334         // Get the number after llvm.dbg.composite and make UniqueSuffix from
 335         // it.
 336         std::string UniqueSuffix = "." + DIVar.substr(18);
 337         std::string MangledCTyName = name + UniqueSuffix;
 338         unsigned short size = CTy.getSizeInBits()/8;
 339         int Aux[PIC16Dbg::AuxSize] = {0};
 340         // 7th and 8th byte represent size of structure/union.
 341         Aux[6] = size & 0xff;
 342         Aux[7] = size >> 8;
 343         // Emit .def for structure/union tag.
 344         if( CTy.getTag() == dwarf::DW_TAG_union_type)
 345           EmitSymbol(MangledCTyName, PIC16Dbg::C_UNTAG);
 346         else if  (CTy.getTag() == dwarf::DW_TAG_structure_type)
 347           EmitSymbol(MangledCTyName, PIC16Dbg::C_STRTAG);
 348
 349         // Emit auxiliary debug information for structure/union tag.
 350         EmitAuxEntry(MangledCTyName, Aux, PIC16Dbg::AuxSize);
 351
 352         // Emit members.
 353         EmitCompositeTypeElements (CTy, UniqueSuffix);
 354
 355         // Emit mangled Symbol for end of structure/union.
 356         std::string EOSSymbol = ".eos" + UniqueSuffix;
 357         EmitSymbol(EOSSymbol, PIC16Dbg::C_EOS);
 358         EmitAuxEntry(EOSSymbol, Aux, PIC16Dbg::AuxSize, MangledCTyName);
 359       }
 360     }
 361   }
 362 }
 363
 364 /// EmitFunctBeginDI - Emit .bf for function.
 365 ///
 366 void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
 367   std::string FunctName = F->getName();
 368   if (EmitDebugDirectives) {
 369     std::string FunctBeginSym = ".bf." + FunctName;
 370     std::string BlockBeginSym = ".bb." + FunctName;
 371
 372     int BFAux[PIC16Dbg::AuxSize] = {0};
 373     BFAux[4] = CurLine;
 374     BFAux[5] = CurLine >> 8;
 375
 376     // Emit debug directives for beginning of function.
 377     EmitSymbol(FunctBeginSym, PIC16Dbg::C_FCN);
 378     EmitAuxEntry(FunctBeginSym, BFAux, PIC16Dbg::AuxSize);
 379
 380     EmitSymbol(BlockBeginSym, PIC16Dbg::C_BLOCK);
 381     EmitAuxEntry(BlockBeginSym, BFAux, PIC16Dbg::AuxSize);
 382   }
 383 }
 384
 385 /// EmitFunctEndDI - Emit .ef for function end.
 386 ///
 387 void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
 388   std::string FunctName = F->getName();
 389   if (EmitDebugDirectives) {
 390     std::string FunctEndSym = ".ef." + FunctName;
 391     std::string BlockEndSym = ".eb." + FunctName;
 392
 393     // Emit debug directives for end of function.
 394     EmitSymbol(BlockEndSym, PIC16Dbg::C_BLOCK);
 395     int EFAux[PIC16Dbg::AuxSize] = {0};
 396     // 5th and 6th byte stand for line number.
 397     EFAux[4] = CurLine;
 398     EFAux[5] = CurLine >> 8;
 399     EmitAuxEntry(BlockEndSym, EFAux, PIC16Dbg::AuxSize);
 400     EmitSymbol(FunctEndSym, PIC16Dbg::C_FCN);
 401     EmitAuxEntry(FunctEndSym, EFAux, PIC16Dbg::AuxSize);
 402   }
 403 }
 404
 405 /// EmitAuxEntry - Emit Auxiliary debug information.
 406 ///
 407 void PIC16DbgInfo::EmitAuxEntry(const std::string VarName, int Aux[], int Num,
 408                                 std::string TagName) {
 409   O << "\n\t.dim " << VarName << ", 1" ;
 410   // TagName is emitted in case of structure/union objects.
 411   if (TagName != "")
 412     O << ", " << TagName;
 413   for (int i = 0; i<Num; i++)
 414     O << "," << Aux[i];
 415 }
 416
 417 /// EmitSymbol - Emit .def for a symbol. Value is offset for the member.
 418 ///
 419 void PIC16DbgInfo::EmitSymbol(std::string Name, short Class, unsigned short
 420                               Type, unsigned long Value) {
 421   O << "\n\t" << ".def "<< Name << ", type = " << Type << ", class = "
 422     << Class;
 423   if (Value > 0)
 424     O  << ", value = " << Value;
 425 }
 426
 427 /// EmitVarDebugInfo - Emit debug information for all variables.
 428 ///
 429 void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
 430   // FIXME : This anchor has been removed.
 431   GlobalVariable *Root = M.getGlobalVariable("llvm.dbg.global_variables");
 432   if (!Root)
 433     return;
 434
 435   Constant *RootC = cast<Constant>(*Root->use_begin());
 436   for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
 437        UI != UE; ++UI) {
 438     for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
 439          UUI != UUE; ++UUI) {
 440       DIGlobalVariable DIGV(cast<GlobalVariable>(*UUI));
 441       DIType Ty = DIGV.getType();
 442       unsigned short TypeNo = 0;
 443       bool HasAux = false;
 444       int Aux[PIC16Dbg::AuxSize] = { 0 };
 445       std::string TagName = "";
 446       std::string VarName = TAI->getGlobalPrefix()+DIGV.getGlobal()->getName();
 447       PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TagName);
 448       // Emit debug info only if type information is availaible.
 449       if (TypeNo != PIC16Dbg::T_NULL) {
 450         O << "\n\t.type " << VarName << ", " << TypeNo;
 451         short ClassNo = getStorageClass(DIGV);
 452         O << "\n\t.class " << VarName << ", " << ClassNo;
 453         if (HasAux)
 454           EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize, TagName);
 455       }
 456     }
 457   }
 458   O << "\n";
 459 }
 460
 461 /// SwitchToCU - Switch to a new compilation unit.
 462 ///
 463 void PIC16DbgInfo::SwitchToCU(GlobalVariable *CU) {
 464   // Get the file path from CU.
 465   DICompileUnit cu(CU);
 466   std::string DirName, FileName;
 467   std::string FilePath = cu.getDirectory(DirName) + "/" +
 468                          cu.getFilename(FileName);
 469
 470   // Nothing to do if source file is still same.
 471   if ( FilePath == CurFile ) return;
 472
 473   // Else, close the current one and start a new.
 474   if (CurFile != "") O << "\n\t.eof";
 475   O << "\n\t.file\t\"" << FilePath << "\"\n" ;
 476   CurFile = FilePath;
 477   CurLine = 0;
 478 }
 479
 480 /// EmitEOF - Emit .eof for end of file.
 481 ///
 482 void PIC16DbgInfo::EmitEOF() {
 483   if (CurFile != "")
 484     O << "\n\t.EOF";
 485 }
 486