2 //===-- PIC16DebugInfo.cpp - Implementation for PIC16 Debug Information ======//
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 // This file contains the helper functions for representing debug information.
13 //===----------------------------------------------------------------------===//
16 #include "PIC16ABINames.h"
17 #include "PIC16DebugInfo.h"
18 #include "llvm/GlobalVariable.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/MC/MCStreamer.h"
22 #include "llvm/Support/DebugLoc.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
27 /// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
29 void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
30 bool &HasAux, int Aux[],
31 std::string &TagName) {
33 PopulateBasicTypeInfo (Ty, TypeNo);
34 else if (Ty.isCompositeType())
35 PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
36 else if (Ty.isDerivedType())
37 PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
39 TypeNo = PIC16Dbg::T_NULL;
45 /// PopulateBasicTypeInfo- Populate TypeNo for basic type from Ty.
47 void PIC16DbgInfo::PopulateBasicTypeInfo (DIType Ty, unsigned short &TypeNo) {
48 std::string Name = Ty.getName();
49 unsigned short BaseTy = GetTypeDebugNumber(Name);
50 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
51 TypeNo = TypeNo | (0xffff & BaseTy);
54 /// PopulateDerivedTypeInfo - Populate TypeNo, Aux[], TagName for derived type
55 /// from Ty. Derived types are mostly pointers.
57 void PIC16DbgInfo::PopulateDerivedTypeInfo (DIType Ty, unsigned short &TypeNo,
58 bool &HasAux, int Aux[],
59 std::string &TagName) {
63 case dwarf::DW_TAG_pointer_type:
64 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
65 TypeNo = TypeNo | PIC16Dbg::DT_PTR;
68 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
71 // We also need to encode the information about the base type of
73 DIType BaseType = DIDerivedType(Ty.getNode()).getTypeDerivedFrom();
74 PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
77 /// PopulateArrayTypeInfo - Populate TypeNo, Aux[] for array from Ty.
78 void PIC16DbgInfo::PopulateArrayTypeInfo (DIType Ty, unsigned short &TypeNo,
79 bool &HasAux, int Aux[],
80 std::string &TagName) {
82 DICompositeType CTy = DICompositeType(Ty.getNode());
83 DIArray Elements = CTy.getTypeArray();
84 unsigned short size = 1;
85 unsigned short Dimension[4]={0,0,0,0};
86 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
87 DIDescriptor Element = Elements.getElement(i);
88 if (Element.getTag() == dwarf::DW_TAG_subrange_type) {
89 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
90 TypeNo = TypeNo | PIC16Dbg::DT_ARY;
91 DISubrange SubRange = DISubrange(Element.getNode());
92 Dimension[i] = SubRange.getHi() - SubRange.getLo() + 1;
93 // Each dimension is represented by 2 bytes starting at byte 9.
94 Aux[8+i*2+0] = Dimension[i];
95 Aux[8+i*2+1] = Dimension[i] >> 8;
96 size = size * Dimension[i];
100 // In auxillary entry for array, 7th and 8th byte represent array size.
101 Aux[6] = size & 0xff;
103 DIType BaseType = CTy.getTypeDerivedFrom();
104 PopulateDebugInfo(BaseType, TypeNo, HasAux, Aux, TagName);
107 /// PopulateStructOrUnionTypeInfo - Populate TypeNo, Aux[] , TagName for
108 /// structure or union.
110 void PIC16DbgInfo::PopulateStructOrUnionTypeInfo (DIType Ty,
111 unsigned short &TypeNo,
112 bool &HasAux, int Aux[],
113 std::string &TagName) {
114 DICompositeType CTy = DICompositeType(Ty.getNode());
115 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
116 if (Ty.getTag() == dwarf::DW_TAG_structure_type)
117 TypeNo = TypeNo | PIC16Dbg::T_STRUCT;
119 TypeNo = TypeNo | PIC16Dbg::T_UNION;
120 TagName = CTy.getName();
121 // UniqueSuffix is .number where number is obtained from
122 // llvm.dbg.composite<number>.
123 // FIXME: This will break when composite type is not represented by
124 // llvm.dbg.composite* global variable. Since we need to revisit
125 // PIC16DebugInfo implementation anyways after the MDNodes based
126 // framework is done, let us continue with the way it is.
127 std::string UniqueSuffix = "." + Ty.getNode()->getNameStr().substr(18);
128 TagName += UniqueSuffix;
129 unsigned short size = CTy.getSizeInBits()/8;
130 // 7th and 8th byte represent size.
132 Aux[6] = size & 0xff;
136 /// PopulateEnumTypeInfo - Populate TypeNo for enum from Ty.
137 void PIC16DbgInfo::PopulateEnumTypeInfo (DIType Ty, unsigned short &TypeNo) {
138 TypeNo = TypeNo << PIC16Dbg::S_BASIC;
139 TypeNo = TypeNo | PIC16Dbg::T_ENUM;
142 /// PopulateCompositeTypeInfo - Populate TypeNo, Aux[] and TagName for
143 /// composite types from Ty.
145 void PIC16DbgInfo::PopulateCompositeTypeInfo (DIType Ty, unsigned short &TypeNo,
146 bool &HasAux, int Aux[],
147 std::string &TagName) {
148 switch (Ty.getTag()) {
149 case dwarf::DW_TAG_array_type: {
150 PopulateArrayTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
153 case dwarf:: DW_TAG_union_type:
154 case dwarf::DW_TAG_structure_type: {
155 PopulateStructOrUnionTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
158 case dwarf::DW_TAG_enumeration_type: {
159 PopulateEnumTypeInfo (Ty, TypeNo);
163 TypeNo = TypeNo << PIC16Dbg::S_DERIVED;
167 /// GetTypeDebugNumber - Get debug type number for given type.
169 unsigned PIC16DbgInfo::GetTypeDebugNumber(std::string &type) {
171 return PIC16Dbg::T_CHAR;
172 else if (type == "short")
173 return PIC16Dbg::T_SHORT;
174 else if (type == "int")
175 return PIC16Dbg::T_INT;
176 else if (type == "long")
177 return PIC16Dbg::T_LONG;
178 else if (type == "unsigned char")
179 return PIC16Dbg::T_UCHAR;
180 else if (type == "unsigned short")
181 return PIC16Dbg::T_USHORT;
182 else if (type == "unsigned int")
183 return PIC16Dbg::T_UINT;
184 else if (type == "unsigned long")
185 return PIC16Dbg::T_ULONG;
190 /// GetStorageClass - Get storage class for give debug variable.
192 short PIC16DbgInfo::getStorageClass(DIGlobalVariable DIGV) {
194 if (PAN::isLocalName(DIGV.getName())) {
195 // Generating C_AUTO here fails due to error in linker. Change it once
197 ClassNo = PIC16Dbg::C_STAT;
199 else if (DIGV.isLocalToUnit())
200 ClassNo = PIC16Dbg::C_STAT;
202 ClassNo = PIC16Dbg::C_EXT;
206 /// BeginModule - Emit necessary debug info to start a Module and do other
207 /// required initializations.
208 void PIC16DbgInfo::BeginModule(Module &M) {
209 // Emit file directive for module.
210 DebugInfoFinder DbgFinder;
211 DbgFinder.processModule(M);
212 if (DbgFinder.compile_unit_count() != 0) {
213 // FIXME : What if more then one CUs are present in a module ?
214 MDNode *CU = *DbgFinder.compile_unit_begin();
215 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 SwitchToCU(DL.getScope(MF.getFunction()->getContext()));
263 SwitchToLine(DL.getLine(), IsInBeginFunction);
266 /// SwitchToLine - Emit line directive for a new line.
268 void PIC16DbgInfo::SwitchToLine(unsigned Line, bool IsInBeginFunction) {
269 if (CurLine == Line) return;
270 if (!IsInBeginFunction)
271 OS.EmitRawText("\n\t.line " + Twine(Line));
275 /// EndFunction - Emit .ef for end of function.
277 void PIC16DbgInfo::EndFunction(const MachineFunction &MF) {
278 if (! EmitDebugDirectives) return;
279 const DebugLoc &DL = GetDebugLocForFunction(MF);
280 // Emit debug info only if valid debug info is available.
282 EmitFunctEndDI(MF.getFunction(), CurLine);
285 /// EndModule - Emit .eof for end of module.
287 void PIC16DbgInfo::EndModule(Module &M) {
288 if (! EmitDebugDirectives) return;
290 if (CurFile != "") OS.EmitRawText(StringRef("\n\t.eof"));
293 /// EmitCompositeTypeElements - Emit debug information for members of a
296 void PIC16DbgInfo::EmitCompositeTypeElements (DICompositeType CTy,
297 std::string SuffixNo) {
298 unsigned long Value = 0;
299 DIArray Elements = CTy.getTypeArray();
300 for (unsigned i = 0, N = Elements.getNumElements(); i < N; i++) {
301 DIDescriptor Element = Elements.getElement(i);
302 unsigned short TypeNo = 0;
304 int ElementAux[PIC16Dbg::AuxSize] = { 0 };
305 std::string TagName = "";
306 DIDerivedType DITy(Element.getNode());
307 unsigned short ElementSize = DITy.getSizeInBits()/8;
308 // Get mangleddd name for this structure/union element.
309 std::string MangMemName = DITy.getName().str() + SuffixNo;
310 PopulateDebugInfo(DITy, TypeNo, HasAux, ElementAux, TagName);
312 if( CTy.getTag() == dwarf::DW_TAG_union_type)
313 Class = PIC16Dbg::C_MOU;
314 else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
315 Class = PIC16Dbg::C_MOS;
316 EmitSymbol(MangMemName.c_str(), Class, TypeNo, Value);
317 if (CTy.getTag() == dwarf::DW_TAG_structure_type)
318 Value += ElementSize;
320 EmitAuxEntry(MangMemName.c_str(), ElementAux, PIC16Dbg::AuxSize, TagName);
324 /// EmitCompositeTypeDecls - Emit composite type declarations like structure
325 /// and union declarations.
327 void PIC16DbgInfo::EmitCompositeTypeDecls(Module &M) {
328 DebugInfoFinder DbgFinder;
329 DbgFinder.processModule(M);
330 for (DebugInfoFinder::iterator I = DbgFinder.type_begin(),
331 E = DbgFinder.type_end(); I != E; ++I) {
332 DICompositeType CTy(*I);
335 if (CTy.getTag() == dwarf::DW_TAG_union_type ||
336 CTy.getTag() == dwarf::DW_TAG_structure_type ) {
337 // Get the number after llvm.dbg.composite and make UniqueSuffix from
339 std::string DIVar = CTy.getNode()->getNameStr();
340 std::string UniqueSuffix = "." + DIVar.substr(18);
341 std::string MangledCTyName = CTy.getName().str() + UniqueSuffix;
342 unsigned short size = CTy.getSizeInBits()/8;
343 int Aux[PIC16Dbg::AuxSize] = {0};
344 // 7th and 8th byte represent size of structure/union.
345 Aux[6] = size & 0xff;
347 // Emit .def for structure/union tag.
348 if( CTy.getTag() == dwarf::DW_TAG_union_type)
349 EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_UNTAG);
350 else if (CTy.getTag() == dwarf::DW_TAG_structure_type)
351 EmitSymbol(MangledCTyName.c_str(), PIC16Dbg::C_STRTAG);
353 // Emit auxiliary debug information for structure/union tag.
354 EmitAuxEntry(MangledCTyName.c_str(), Aux, PIC16Dbg::AuxSize);
357 EmitCompositeTypeElements (CTy, UniqueSuffix);
359 // Emit mangled Symbol for end of structure/union.
360 std::string EOSSymbol = ".eos" + UniqueSuffix;
361 EmitSymbol(EOSSymbol.c_str(), PIC16Dbg::C_EOS);
362 EmitAuxEntry(EOSSymbol.c_str(), Aux, PIC16Dbg::AuxSize,
363 MangledCTyName.c_str());
369 /// EmitFunctBeginDI - Emit .bf for function.
371 void PIC16DbgInfo::EmitFunctBeginDI(const Function *F) {
372 std::string FunctName = F->getName();
373 if (EmitDebugDirectives) {
374 std::string FunctBeginSym = ".bf." + FunctName;
375 std::string BlockBeginSym = ".bb." + FunctName;
377 int BFAux[PIC16Dbg::AuxSize] = {0};
379 BFAux[5] = CurLine >> 8;
381 // Emit debug directives for beginning of function.
382 EmitSymbol(FunctBeginSym, PIC16Dbg::C_FCN);
383 EmitAuxEntry(FunctBeginSym, BFAux, PIC16Dbg::AuxSize);
385 EmitSymbol(BlockBeginSym, PIC16Dbg::C_BLOCK);
386 EmitAuxEntry(BlockBeginSym, BFAux, PIC16Dbg::AuxSize);
390 /// EmitFunctEndDI - Emit .ef for function end.
392 void PIC16DbgInfo::EmitFunctEndDI(const Function *F, unsigned Line) {
393 std::string FunctName = F->getName();
394 if (EmitDebugDirectives) {
395 std::string FunctEndSym = ".ef." + FunctName;
396 std::string BlockEndSym = ".eb." + FunctName;
398 // Emit debug directives for end of function.
399 EmitSymbol(BlockEndSym, PIC16Dbg::C_BLOCK);
400 int EFAux[PIC16Dbg::AuxSize] = {0};
401 // 5th and 6th byte stand for line number.
403 EFAux[5] = CurLine >> 8;
404 EmitAuxEntry(BlockEndSym, EFAux, PIC16Dbg::AuxSize);
405 EmitSymbol(FunctEndSym, PIC16Dbg::C_FCN);
406 EmitAuxEntry(FunctEndSym, EFAux, PIC16Dbg::AuxSize);
410 /// EmitAuxEntry - Emit Auxiliary debug information.
412 void PIC16DbgInfo::EmitAuxEntry(const std::string VarName, int Aux[], int Num,
413 std::string TagName) {
415 // TagName is emitted in case of structure/union objects.
416 if (!TagName.empty()) Tmp += ", " + TagName;
418 for (int i = 0; i<Num; i++)
419 Tmp += "," + utostr(Aux[i] && 0xff);
421 OS.EmitRawText("\n\t.dim " + Twine(VarName) + ", 1" + Tmp);
424 /// EmitSymbol - Emit .def for a symbol. Value is offset for the member.
426 void PIC16DbgInfo::EmitSymbol(std::string Name, short Class,
427 unsigned short Type, unsigned long Value) {
430 Tmp = ", value = " + utostr(Value);
432 OS.EmitRawText("\n\t.def " + Twine(Name) + ", type = " + utostr(Type) +
433 ", class = " + utostr(Class) + Tmp);
436 /// EmitVarDebugInfo - Emit debug information for all variables.
438 void PIC16DbgInfo::EmitVarDebugInfo(Module &M) {
439 DebugInfoFinder DbgFinder;
440 DbgFinder.processModule(M);
442 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
443 E = DbgFinder.global_variable_end(); I != E; ++I) {
444 DIGlobalVariable DIGV(*I);
445 DIType Ty = DIGV.getType();
446 unsigned short TypeNo = 0;
448 int Aux[PIC16Dbg::AuxSize] = { 0 };
449 std::string TagName = "";
450 std::string VarName = DIGV.getName();
451 VarName = MAI->getGlobalPrefix() + VarName;
452 PopulateDebugInfo(Ty, TypeNo, HasAux, Aux, TagName);
453 // Emit debug info only if type information is availaible.
454 if (TypeNo != PIC16Dbg::T_NULL) {
455 OS.EmitRawText("\t.type " + Twine(VarName) + ", " + Twine(TypeNo));
456 short ClassNo = getStorageClass(DIGV);
457 OS.EmitRawText("\t.class " + Twine(VarName) + ", " + Twine(ClassNo));
459 EmitAuxEntry(VarName, Aux, PIC16Dbg::AuxSize, TagName);
464 /// SwitchToCU - Switch to a new compilation unit.
466 void PIC16DbgInfo::SwitchToCU(MDNode *CU) {
467 // Get the file path from CU.
468 DICompileUnit cu(CU);
469 std::string DirName = cu.getDirectory();
470 std::string FileName = cu.getFilename();
471 std::string FilePath = DirName + "/" + FileName;
473 // Nothing to do if source file is still same.
474 if ( FilePath == CurFile ) return;
476 // Else, close the current one and start a new.
478 OS.EmitRawText(StringRef("\t.eof"));
479 OS.EmitRawText("\n\t.file\t\"" + Twine(FilePath) + "\"");
484 /// EmitEOF - Emit .eof for end of file.
486 void PIC16DbgInfo::EmitEOF() {
488 OS.EmitRawText(StringRef("\t.EOF"));