1 //===-- PIC16DebugInfo.cpp - Implementation for PIC16 Debug Information ======//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the helper functions for representing debug information.
12 //===----------------------------------------------------------------------===//
15 #include "PIC16DebugInfo.h"
16 #include "llvm/GlobalVariable.h"
17 #include "llvm/CodeGen/MachineFunction.h"
18 #include "llvm/MC/MCAsmInfo.h"
19 #include "llvm/Support/DebugLoc.h"
20 #include "llvm/Support/FormattedStream.h"
21 #include "llvm/ADT/SmallString.h"
25 /// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
27 void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
28 bool &HasAux, int Aux[],
29 std::string &TagName) {
30 if (Ty.isBasicType(Ty.getTag()))
31 PopulateBasicTypeInfo (Ty, TypeNo);
32 else if (Ty.isDerivedType(Ty.getTag()))
33 PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
34 else if (Ty.isCompositeType(Ty.getTag()))
35 PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
37 TypeNo = PIC16Dbg::T_NULL;
43 /// PopulateBasicTypeInfo- Populate TypeNo for basic type from Ty.
45 void PIC16DbgInfo::PopulateBasicTypeInfo (DIType Ty, unsigned short &TypeNo) {
46 std::string Name = "";
48 unsigned short BaseTy = GetTypeDebugNumber(Name);
49 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
50 TypeNo = TypeNo | (0xffff & BaseTy);
53 /// PopulateDerivedTypeInfo - Populate TypeNo, Aux[], TagName for derived type
54 /// from Ty. Derived types are mostly pointers.
56 void PIC16DbgInfo::PopulateDerivedTypeInfo (DIType Ty, unsigned short &TypeNo,
57 bool &HasAux, int Aux[],
58 std::string &TagName) {
62 case dwarf::DW_TAG_pointer_type:
63 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
64 TypeNo = TypeNo | PIC16Dbg::DT_PTR;
67 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
70 // We also need to encode the the information about the base type of
72 DIType BaseType = DIDerivedType(Ty.getGV()).getTypeDerivedFrom();
73 PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
76 /// PopulateArrayTypeInfo - Populate TypeNo, Aux[] for array from Ty.
77 void PIC16DbgInfo::PopulateArrayTypeInfo (DIType Ty, unsigned short &TypeNo,
78 bool &HasAux, int Aux[],
79 std::string &TagName) {
81 DICompositeType CTy = DICompositeType(Ty.getGV());
82 DIArray Elements = CTy.getTypeArray();
83 unsigned short size = 1;
84 unsigned short Dimension[4]={0,0,0,0};
85 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
86 DIDescriptor Element = Elements.getElement(i);
87 if (Element.getTag() == dwarf::DW_TAG_subrange_type) {
88 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
89 TypeNo = TypeNo | PIC16Dbg::DT_ARY;
90 DISubrange SubRange = DISubrange(Element.getGV());
91 Dimension[i] = SubRange.getHi() - SubRange.getLo() + 1;
92 // Each dimension is represented by 2 bytes starting at byte 9.
93 Aux[8+i*2+0] = Dimension[i];
94 Aux[8+i*2+1] = Dimension[i] >> 8;
95 size = size * Dimension[i];
99 // In auxillary entry for array, 7th and 8th byte represent array size.
100 Aux[6] = size & 0xff;
102 DIType BaseType = CTy.getTypeDerivedFrom();
103 PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
106 /// PopulateStructOrUnionTypeInfo - Populate TypeNo, Aux[] , TagName for
107 /// structure or union.
109 void PIC16DbgInfo::PopulateStructOrUnionTypeInfo (DIType Ty,
110 unsigned short &TypeNo,
111 bool &HasAux, int Aux[],
112 std::string &TagName) {
113 DICompositeType CTy = DICompositeType(Ty.getGV());
114 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
115 if (Ty.getTag() == dwarf::DW_TAG_structure_type)
116 TypeNo = TypeNo | PIC16Dbg::T_STRUCT;
118 TypeNo = TypeNo | PIC16Dbg::T_UNION;
119 CTy.getName(TagName);
120 // UniqueSuffix is .number where number is obtained from
121 // llvm.dbg.composite<number>.
122 // FIXME: This will break when composite type is not represented by
123 // llvm.dbg.composite* global variable. Since we need to revisit
124 // PIC16DebugInfo implementation anyways after the MDNodes based
125 // framework is done, let us continue with the way it is.
126 std::string UniqueSuffix = "." + Ty.getGV()->getNameStr().substr(18);
127 TagName += UniqueSuffix;
128 unsigned short size = CTy.getSizeInBits()/8;
129 // 7th and 8th byte represent size.
131 Aux[6] = size & 0xff;
135 /// PopulateEnumTypeInfo - Populate TypeNo for enum from Ty.
136 void PIC16DbgInfo::PopulateEnumTypeInfo (DIType Ty, unsigned short &TypeNo) {
137 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
138 TypeNo = TypeNo | PIC16Dbg::T_ENUM;
141 /// PopulateCompositeTypeInfo - Populate TypeNo, Aux[] and TagName for
142 /// composite types from Ty.
144 void PIC16DbgInfo::PopulateCompositeTypeInfo (DIType Ty, unsigned short &TypeNo,
145 bool &HasAux, int Aux[],
146 std::string &TagName) {
147 switch (Ty.getTag()) {
148 case dwarf::DW_TAG_array_type: {
149 PopulateArrayTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
152 case dwarf:: DW_TAG_union_type:
153 case dwarf::DW_TAG_structure_type: {
154 PopulateStructOrUnionTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
157 case dwarf::DW_TAG_enumeration_type: {
158 PopulateEnumTypeInfo (Ty, TypeNo);
162 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
166 /// GetTypeDebugNumber - Get debug type number for given type.
168 unsigned PIC16DbgInfo::GetTypeDebugNumber(std::string &type) {
170 return PIC16Dbg::T_CHAR;
171 else if (type == "short")
172 return PIC16Dbg::T_SHORT;
173 else if (type == "int")
174 return PIC16Dbg::T_INT;
175 else if (type == "long")
176 return PIC16Dbg::T_LONG;
177 else if (type == "unsigned char")
178 return PIC16Dbg::T_UCHAR;
179 else if (type == "unsigned short")
180 return PIC16Dbg::T_USHORT;
181 else if (type == "unsigned int")
182 return PIC16Dbg::T_UINT;
183 else if (type == "unsigned long")
184 return PIC16Dbg::T_ULONG;
189 /// GetStorageClass - Get storage class for give debug variable.
191 short PIC16DbgInfo::getStorageClass(DIGlobalVariable DIGV) {
193 if (PAN::isLocalName(DIGV.getGlobal()->getName())) {
194 // Generating C_AUTO here fails due to error in linker. Change it once
196 ClassNo = PIC16Dbg::C_STAT;
198 else if (DIGV.isLocalToUnit())
199 ClassNo = PIC16Dbg::C_STAT;
201 ClassNo = PIC16Dbg::C_EXT;
205 /// BeginModule - Emit necessary debug info to start a Module and do other
206 /// required initializations.
207 void PIC16DbgInfo::BeginModule(Module &M) {
208 // Emit file directive for module.
209 DebugInfoFinder DbgFinder;
210 DbgFinder.processModule(M);
211 if (DbgFinder.compile_unit_count() != 0) {
212 // FIXME : What if more then one CUs are present in a module ?
213 GlobalVariable *CU = *DbgFinder.compile_unit_begin();
214 EmitDebugDirectives = true;
218 // Emit debug info for decls of composite types.
219 EmitCompositeTypeDecls(M);
222 /// Helper to find first valid debug loc for a function.
224 static const DebugLoc GetDebugLocForFunction(const MachineFunction &MF) {
226 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
228 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
230 DL = II->getDebugLoc();
238 /// BeginFunction - Emit necessary debug info to start a function.
240 void PIC16DbgInfo::BeginFunction(const MachineFunction &MF) {
241 if (! EmitDebugDirectives) return;
243 // Retreive the first valid debug Loc and process it.
244 const DebugLoc &DL = GetDebugLocForFunction(MF);
245 // Emit debug info only if valid debug info is available.
246 if (!DL.isUnknown()) {
247 ChangeDebugLoc(MF, DL, true);
248 EmitFunctBeginDI(MF.getFunction());
250 // Set current line to 0 so that.line directive is genearted after .bf.
254 /// ChangeDebugLoc - Take necessary steps when DebugLoc changes.
255 /// CurFile and CurLine may change as a result of this.
257 void PIC16DbgInfo::ChangeDebugLoc(const MachineFunction &MF,
258 const DebugLoc &DL, bool IsInBeginFunction) {
259 if (! EmitDebugDirectives) return;
260 assert (! DL.isUnknown() && "can't change to invalid debug loc");
262 GlobalVariable *CU = MF.getDebugLocTuple(DL).CompileUnit;
263 unsigned line = MF.getDebugLocTuple(DL).Line;
266 SwitchToLine(line, IsInBeginFunction);
269 /// SwitchToLine - Emit line directive for a new line.
271 void PIC16DbgInfo::SwitchToLine(unsigned Line, bool IsInBeginFunction) {
272 if (CurLine == Line) return;
273 if (!IsInBeginFunction) O << "\n\t.line " << Line << "\n";
277 /// EndFunction - Emit .ef for end of function.
279 void PIC16DbgInfo::EndFunction(const MachineFunction &MF) {
280 if (! EmitDebugDirectives) return;
281 const DebugLoc &DL = GetDebugLocForFunction(MF);
282 // Emit debug info only if valid debug info is available.
284 EmitFunctEndDI(MF.getFunction(), CurLine);
287 /// EndModule - Emit .eof for end of module.
289 void PIC16DbgInfo::EndModule(Module &M) {
290 if (! EmitDebugDirectives) return;
292 if (CurFile != "") O << "\n\t.eof";
295 /// EmitCompositeTypeElements - Emit debug information for members of a
298 void PIC16DbgInfo::EmitCompositeTypeElements (DICompositeType CTy,
299 std::string SuffixNo) {
300 unsigned long Value = 0;
301 DIArray Elements = CTy.getTypeArray();
302 for (unsigned i = 0, N = Elements.getNumElements(); i < N; i++) {
303 DIDescriptor Element = Elements.getElement(i);
304 unsigned short TypeNo = 0;
306 int ElementAux[PIC16Dbg::AuxSize] = { 0 };
307 std::string TagName = "";
308 std::string ElementName;
309 GlobalVariable *GV = Element.getGV();
310 DIDerivedType DITy(GV);
311 DITy.getName(ElementName);
312 unsigned short ElementSize = DITy.getSizeInBits()/8;
313 // Get mangleddd name for this structure/union element.
314 std::string MangMemName = ElementName + SuffixNo;
315 PopulateDebugInfo(DITy, TypeNo, HasAux, ElementAux, TagName);
317 if( CTy.getTag() == dwarf::DW_TAG_union_type)
318 Class = PIC16Dbg::C_MOU;
319 else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
320 Class = PIC16Dbg::C_MOS;
321 EmitSymbol(MangMemName.c_str(), Class, TypeNo, Value);
322 if (CTy.getTag() == dwarf::DW_TAG_structure_type)
323 Value += ElementSize;
325 EmitAuxEntry(MangMemName.c_str(), ElementAux, PIC16Dbg::AuxSize, TagName);
329 /// EmitCompositeTypeDecls - Emit composite type declarations like structure
330 /// and union declarations.
332 void PIC16DbgInfo::EmitCompositeTypeDecls(Module &M) {
333 DebugInfoFinder DbgFinder;
334 DbgFinder.processModule(M);
335 for (DebugInfoFinder::iterator I = DbgFinder.type_begin(),
336 E = DbgFinder.type_end(); I != E; ++I) {
337 DICompositeType CTy(*I);
340 if (CTy.getTag() == dwarf::DW_TAG_union_type ||
341 CTy.getTag() == dwarf::DW_TAG_structure_type ) {
344 // Get the number after llvm.dbg.composite and make UniqueSuffix from
346 std::string DIVar = CTy.getGV()->getNameStr();
347 std::string UniqueSuffix = "." + DIVar.substr(18);
348 std::string MangledCTyName = Name + UniqueSuffix;
349 unsigned short size = CTy.getSizeInBits()/8;
350 int Aux[PIC16Dbg::AuxSize] = {0};
351 // 7th and 8th byte represent size of structure/union.
352 Aux[6] = size & 0xff;
354 // Emit .def for structure/union tag.
355 if( CTy.getTag() == dwarf::DW_TAG_union_type)
356 EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_UNTAG);
357 else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
358 EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_STRTAG);
360 // Emit auxiliary debug information for structure/union tag.
361 EmitAuxEntry(MangledCTyName.c_str(), Aux, PIC16Dbg::AuxSize);
364 EmitCompositeTypeElements (CTy, UniqueSuffix);
366 // Emit mangled Symbol for end of structure/union.
367 std::string EOSSymbol = ".eos" + UniqueSuffix;
368 EmitSymbol(EOSSymbol.c_str(), PIC16Dbg::C_EOS);
369 EmitAuxEntry(EOSSymbol.c_str(), Aux, PIC16Dbg::AuxSize,
370 MangledCTyName.c_str());
376 /// EmitFunctBeginDI - Emit .bf for function.
378 void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
379 std::string FunctName = F->getName();
380 if (EmitDebugDirectives) {
381 std::string FunctBeginSym = ".bf." + FunctName;
382 std::string BlockBeginSym = ".bb." + FunctName;
384 int BFAux[PIC16Dbg::AuxSize] = {0};
386 BFAux[5] = CurLine >> 8;
388 // Emit debug directives for beginning of function.
389 EmitSymbol(FunctBeginSym, PIC16Dbg::C_FCN);
390 EmitAuxEntry(FunctBeginSym, BFAux, PIC16Dbg::AuxSize);
392 EmitSymbol(BlockBeginSym, PIC16Dbg::C_BLOCK);
393 EmitAuxEntry(BlockBeginSym, BFAux, PIC16Dbg::AuxSize);
397 /// EmitFunctEndDI - Emit .ef for function end.
399 void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
400 std::string FunctName = F->getName();
401 if (EmitDebugDirectives) {
402 std::string FunctEndSym = ".ef." + FunctName;
403 std::string BlockEndSym = ".eb." + FunctName;
405 // Emit debug directives for end of function.
406 EmitSymbol(BlockEndSym, PIC16Dbg::C_BLOCK);
407 int EFAux[PIC16Dbg::AuxSize] = {0};
408 // 5th and 6th byte stand for line number.
410 EFAux[5] = CurLine >> 8;
411 EmitAuxEntry(BlockEndSym, EFAux, PIC16Dbg::AuxSize);
412 EmitSymbol(FunctEndSym, PIC16Dbg::C_FCN);
413 EmitAuxEntry(FunctEndSym, EFAux, PIC16Dbg::AuxSize);
417 /// EmitAuxEntry - Emit Auxiliary debug information.
419 void PIC16DbgInfo::EmitAuxEntry(const std::string VarName, int Aux[], int Num,
420 std::string TagName) {
421 O << "\n\t.dim " << VarName << ", 1" ;
422 // TagName is emitted in case of structure/union objects.
424 O << ", " << TagName;
425 for (int i = 0; i<Num; i++)
429 /// EmitSymbol - Emit .def for a symbol. Value is offset for the member.
431 void PIC16DbgInfo::EmitSymbol(std::string Name, short Class, unsigned short
432 Type, unsigned long Value) {
433 O << "\n\t" << ".def "<< Name << ", type = " << Type << ", class = "
436 O << ", value = " << Value;
439 /// EmitVarDebugInfo - Emit debug information for all variables.
441 void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
442 DebugInfoFinder DbgFinder;
443 DbgFinder.processModule(M);
445 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
446 E = DbgFinder.global_variable_end(); I != E; ++I) {
447 DIGlobalVariable DIGV(*I);
448 DIType Ty = DIGV.getType();
449 unsigned short TypeNo = 0;
451 int Aux[PIC16Dbg::AuxSize] = { 0 };
452 std::string TagName = "";
453 std::string VarName = TAI->getGlobalPrefix()+DIGV.getGlobal()->getNameStr();
454 PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TagName);
455 // Emit debug info only if type information is availaible.
456 if (TypeNo != PIC16Dbg::T_NULL) {
457 O << "\n\t.type " << VarName << ", " << TypeNo;
458 short ClassNo = getStorageClass(DIGV);
459 O << "\n\t.class " << VarName << ", " << ClassNo;
461 EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize, TagName);
467 /// SwitchToCU - Switch to a new compilation unit.
469 void PIC16DbgInfo::SwitchToCU(GlobalVariable *CU) {
470 // Get the file path from CU.
471 DICompileUnit cu(CU);
472 std::string DirName, FileName;
473 std::string FilePath = cu.getDirectory(DirName) + "/" +
474 cu.getFilename(FileName);
476 // Nothing to do if source file is still same.
477 if ( FilePath == CurFile ) return;
479 // Else, close the current one and start a new.
480 if (CurFile != "") O << "\n\t.eof";
481 O << "\n\t.file\t\"" << FilePath << "\"\n" ;
486 /// EmitEOF - Emit .eof for end of file.
488 void PIC16DbgInfo::EmitEOF() {