// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // TODO/NICETOHAVE: // - eliminate DW_CLS_ if not used // - package info in compilation units // - assign global variables and types to their packages // - gdb uses c syntax, meaning clumsy quoting is needed for go identifiers. eg // ptype struct '[]uint8' and qualifiers need to be quoted away // - lexical scoping is lost, so gdb gets confused as to which 'main.i' you mean. // - file:line info for variables // - make strings a typedef so prettyprinters can see the underlying string type // #include "l.h" #include "lib.h" #include "../ld/dwarf.h" #include "../ld/dwarf_defs.h" #include "../ld/elf.h" #include "../ld/macho.h" #include "../ld/pe.h" /* * Offsets and sizes of the debug_* sections in the cout file. */ static vlong abbrevo; static vlong abbrevsize; static vlong lineo; static vlong linesize; static vlong infoo; // also the base for DWDie->offs and reference attributes. static vlong infosize; static vlong frameo; static vlong framesize; static vlong pubnameso; static vlong pubnamessize; static vlong pubtypeso; static vlong pubtypessize; static vlong arangeso; static vlong arangessize; static vlong gdbscripto; static vlong gdbscriptsize; static char gdbscript[1024]; /* * Basic I/O */ static void addrput(vlong addr) { switch(PtrSize) { case 4: LPUT(addr); break; case 8: VPUT(addr); break; } } static int uleb128enc(uvlong v, char* dst) { uint8 c, len; len = 0; do { c = v & 0x7f; v >>= 7; if (v) c |= 0x80; if (dst) *dst++ = c; len++; } while (c & 0x80); return len; }; static int sleb128enc(vlong v, char *dst) { uint8 c, s, len; len = 0; do { c = v & 0x7f; s = v & 0x40; v >>= 7; if ((v != -1 || !s) && (v != 0 || s)) c |= 0x80; if (dst) *dst++ = c; len++; } while(c & 0x80); return len; } static void uleb128put(vlong v) { char buf[10]; strnput(buf, uleb128enc(v, buf)); } static void sleb128put(vlong v) { char buf[10]; strnput(buf, sleb128enc(v, buf)); } /* * Defining Abbrevs. This is hardcoded, and there will be * only a handful of them. The DWARF spec places no restriction on * the ordering of atributes in the Abbrevs and DIEs, and we will * always write them out in the order of declaration in the abbrev. * This implementation relies on tag, attr < 127, so they serialize as * a char. Higher numbered user-defined tags or attributes can be used * for storing internal data but won't be serialized. */ typedef struct DWAttrForm DWAttrForm; struct DWAttrForm { uint8 attr; uint8 form; }; // Index into the abbrevs table below. // Keep in sync with ispubname() and ispubtype() below. // ispubtype considers >= NULLTYPE public enum { DW_ABRV_NULL, DW_ABRV_COMPUNIT, DW_ABRV_FUNCTION, DW_ABRV_VARIABLE, DW_ABRV_AUTO, DW_ABRV_PARAM, DW_ABRV_STRUCTFIELD, DW_ABRV_FUNCTYPEPARAM, DW_ABRV_DOTDOTDOT, DW_ABRV_ARRAYRANGE, DW_ABRV_NULLTYPE, DW_ABRV_BASETYPE, DW_ABRV_ARRAYTYPE, DW_ABRV_CHANTYPE, DW_ABRV_FUNCTYPE, DW_ABRV_IFACETYPE, DW_ABRV_MAPTYPE, DW_ABRV_PTRTYPE, DW_ABRV_SLICETYPE, DW_ABRV_STRINGTYPE, DW_ABRV_STRUCTTYPE, DW_ABRV_TYPEDECL, DW_NABRV }; typedef struct DWAbbrev DWAbbrev; static struct DWAbbrev { uint8 tag; uint8 children; DWAttrForm attr[30]; } abbrevs[DW_NABRV] = { /* The mandatory DW_ABRV_NULL entry. */ { 0 }, /* COMPUNIT */ { DW_TAG_compile_unit, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_language, DW_FORM_data1, DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_addr, DW_AT_stmt_list, DW_FORM_data4, 0, 0 }, /* FUNCTION */ { DW_TAG_subprogram, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_low_pc, DW_FORM_addr, DW_AT_high_pc, DW_FORM_addr, DW_AT_external, DW_FORM_flag, 0, 0 }, /* VARIABLE */ { DW_TAG_variable, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_location, DW_FORM_block1, DW_AT_type, DW_FORM_ref_addr, DW_AT_external, DW_FORM_flag, 0, 0 }, /* AUTO */ { DW_TAG_variable, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_location, DW_FORM_block1, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* PARAM */ { DW_TAG_formal_parameter, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_location, DW_FORM_block1, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* STRUCTFIELD */ { DW_TAG_member, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_data_member_location, DW_FORM_block1, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* FUNCTYPEPARAM */ { DW_TAG_formal_parameter, DW_CHILDREN_no, // No name! DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* DOTDOTDOT */ { DW_TAG_unspecified_parameters, DW_CHILDREN_no, 0, 0 }, /* ARRAYRANGE */ { DW_TAG_subrange_type, DW_CHILDREN_no, // No name! DW_AT_type, DW_FORM_ref_addr, DW_AT_upper_bound, DW_FORM_data1, 0, 0 }, // Below here are the types considered public by ispubtype /* NULLTYPE */ { DW_TAG_unspecified_type, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, 0, 0 }, /* BASETYPE */ { DW_TAG_base_type, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_encoding, DW_FORM_data1, DW_AT_byte_size, DW_FORM_data1, 0, 0 }, /* ARRAYTYPE */ // child is subrange with upper bound { DW_TAG_array_type, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, DW_AT_byte_size, DW_FORM_udata, 0, 0 }, /* CHANTYPE */ { DW_TAG_typedef, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* FUNCTYPE */ { DW_TAG_subroutine_type, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, // DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* IFACETYPE */ { DW_TAG_typedef, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* MAPTYPE */ { DW_TAG_typedef, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* PTRTYPE */ { DW_TAG_pointer_type, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, /* SLICETYPE */ { DW_TAG_structure_type, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_byte_size, DW_FORM_udata, 0, 0 }, /* STRINGTYPE */ { DW_TAG_structure_type, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_byte_size, DW_FORM_udata, 0, 0 }, /* STRUCTTYPE */ { DW_TAG_structure_type, DW_CHILDREN_yes, DW_AT_name, DW_FORM_string, DW_AT_byte_size, DW_FORM_udata, 0, 0 }, /* TYPEDECL */ { DW_TAG_typedef, DW_CHILDREN_no, DW_AT_name, DW_FORM_string, DW_AT_type, DW_FORM_ref_addr, 0, 0 }, }; static void writeabbrev(void) { int i, n; abbrevo = cpos(); for (i = 1; i < DW_NABRV; i++) { // See section 7.5.3 uleb128put(i); uleb128put(abbrevs[i].tag); cput(abbrevs[i].children); // 0 is not a valid attr or form, and DWAbbrev.attr is // 0-terminated, so we can treat it as a string n = strlen((char*)abbrevs[i].attr) / 2; strnput((char*)abbrevs[i].attr, (n+1) * sizeof(DWAttrForm)); } cput(0); abbrevsize = cpos() - abbrevo; } /* * Debugging Information Entries and their attributes. */ enum { HASHSIZE = 107 }; static uint32 hashstr(char* s) { uint32 h; h = 0; while (*s) h = h+h+h + *s++; return h % HASHSIZE; } // For DW_CLS_string and _block, value should contain the length, and // data the data, for _reference, value is 0 and data is a DWDie* to // the referenced instance, for all others, value is the whole thing // and data is null. typedef struct DWAttr DWAttr; struct DWAttr { DWAttr *link; uint8 atr; // DW_AT_ uint8 cls; // DW_CLS_ vlong value; char *data; }; typedef struct DWDie DWDie; struct DWDie { int abbrev; DWDie *link; DWDie *child; DWAttr *attr; // offset into .debug_info section, i.e relative to // infoo. only valid after call to putdie() vlong offs; DWDie **hash; // optional index of children by name, enabled by mkindex() DWDie *hlink; // bucket chain in parent's index }; /* * Root DIEs for compilation units, types and global variables. */ static DWDie dwroot; static DWDie dwtypes; static DWDie dwglobals; static DWAttr* newattr(DWDie *die, uint8 attr, int cls, vlong value, char *data) { DWAttr *a; a = mal(sizeof *a); a->link = die->attr; die->attr = a; a->atr = attr; a->cls = cls; a->value = value; a->data = data; return a; } // Each DIE (except the root ones) has at least 1 attribute: its // name. getattr moves the desired one to the front so // frequently searched ones are found faster. static DWAttr* getattr(DWDie *die, uint8 attr) { DWAttr *a, *b; if (die->attr->atr == attr) return die->attr; a = die->attr; b = a->link; while (b != nil) { if (b->atr == attr) { a->link = b->link; b->link = die->attr; die->attr = b; return b; } a = b; b = b->link; } return nil; } // Every DIE has at least a DW_AT_name attribute (but it will only be // written out if it is listed in the abbrev). If its parent is // keeping an index, the new DIE will be inserted there. static DWDie* newdie(DWDie *parent, int abbrev, char *name) { DWDie *die; int h; die = mal(sizeof *die); die->abbrev = abbrev; die->link = parent->child; parent->child = die; newattr(die, DW_AT_name, DW_CLS_STRING, strlen(name), name); if (parent->hash) { h = hashstr(name); die->hlink = parent->hash[h]; parent->hash[h] = die; } return die; } static void mkindex(DWDie *die) { die->hash = mal(HASHSIZE * sizeof(DWDie*)); } // Find child by AT_name using hashtable if available or linear scan // if not. static DWDie* find(DWDie *die, char* name) { DWDie *a, *b; int h; if (die->hash == nil) { for (a = die->child; a != nil; a = a->link) if (strcmp(name, getattr(a, DW_AT_name)->data) == 0) return a; return nil; } h = hashstr(name); a = die->hash[h]; if (a == nil) return nil; if (strcmp(name, getattr(a, DW_AT_name)->data) == 0) return a; // Move found ones to head of the list. b = a->hlink; while (b != nil) { if (strcmp(name, getattr(b, DW_AT_name)->data) == 0) { a->hlink = b->hlink; b->hlink = die->hash[h]; die->hash[h] = b; return b; } a = b; b = b->hlink; } return nil; } static DWDie* find_or_diag(DWDie *die, char* name) { DWDie *r; r = find(die, name); if (r == nil) { diag("dwarf find: %s has no %s", getattr(die, DW_AT_name)->data, name); errorexit(); } return r; } static DWAttr* newrefattr(DWDie *die, uint8 attr, DWDie* ref) { if (ref == nil) return nil; return newattr(die, attr, DW_CLS_REFERENCE, 0, (char*)ref); } static int fwdcount; static void putattr(int form, int cls, vlong value, char *data) { switch(form) { case DW_FORM_addr: // address addrput(value); break; case DW_FORM_block1: // block value &= 0xff; cput(value); while(value--) cput(*data++); break; case DW_FORM_block2: // block value &= 0xffff; WPUT(value); while(value--) cput(*data++); break; case DW_FORM_block4: // block value &= 0xffffffff; LPUT(value); while(value--) cput(*data++); break; case DW_FORM_block: // block uleb128put(value); while(value--) cput(*data++); break; case DW_FORM_data1: // constant cput(value); break; case DW_FORM_data2: // constant WPUT(value); break; case DW_FORM_data4: // constant, {line,loclist,mac,rangelist}ptr LPUT(value); break; case DW_FORM_data8: // constant, {line,loclist,mac,rangelist}ptr VPUT(value); break; case DW_FORM_sdata: // constant sleb128put(value); break; case DW_FORM_udata: // constant uleb128put(value); break; case DW_FORM_string: // string strnput(data, value+1); break; case DW_FORM_flag: // flag cput(value?1:0); break; case DW_FORM_ref_addr: // reference to a DIE in the .info section if (data == nil) { diag("dwarf: null reference"); LPUT(0); // invalid dwarf, gdb will complain. } else { if (((DWDie*)data)->offs == 0) fwdcount++; LPUT(((DWDie*)data)->offs); } break; case DW_FORM_ref1: // reference within the compilation unit case DW_FORM_ref2: // reference case DW_FORM_ref4: // reference case DW_FORM_ref8: // reference case DW_FORM_ref_udata: // reference case DW_FORM_strp: // string case DW_FORM_indirect: // (see Section 7.5.3) default: diag("dwarf: unsupported attribute form %d / class %d", form, cls); errorexit(); } } // Note that we can (and do) add arbitrary attributes to a DIE, but // only the ones actually listed in the Abbrev will be written out. static void putattrs(int abbrev, DWAttr* attr) { DWAttr *attrs[DW_AT_recursive + 1]; DWAttrForm* af; memset(attrs, 0, sizeof attrs); for( ; attr; attr = attr->link) if (attr->atr < nelem(attrs)) attrs[attr->atr] = attr; for(af = abbrevs[abbrev].attr; af->attr; af++) if (attrs[af->attr]) putattr(af->form, attrs[af->attr]->cls, attrs[af->attr]->value, attrs[af->attr]->data); else putattr(af->form, 0, 0, 0); } static void putdie(DWDie* die); static void putdies(DWDie* die) { for(; die; die = die->link) putdie(die); } static void putdie(DWDie* die) { die->offs = cpos() - infoo; uleb128put(die->abbrev); putattrs(die->abbrev, die->attr); if (abbrevs[die->abbrev].children) { putdies(die->child); cput(0); } } static void reverselist(DWDie** list) { DWDie *curr, *prev; curr = *list; prev = nil; while(curr != nil) { DWDie* next = curr->link; curr->link = prev; prev = curr; curr = next; } *list = prev; } static void reversetree(DWDie** list) { DWDie *die; reverselist(list); for (die = *list; die != nil; die = die->link) if (abbrevs[die->abbrev].children) reversetree(&die->child); } static void newmemberoffsetattr(DWDie *die, int32 offs) { char block[10]; int i; i = 0; if (offs != 0) { block[i++] = DW_OP_consts; i += sleb128enc(offs, block+i); block[i++] = DW_OP_plus; } newattr(die, DW_AT_data_member_location, DW_CLS_BLOCK, i, mal(i)); memmove(die->attr->data, block, i); } // GDB doesn't like DW_FORM_addr for DW_AT_location, so emit a // location expression that evals to a const. static void newabslocexprattr(DWDie *die, vlong addr) { char block[10]; int i; i = 0; block[i++] = DW_OP_constu; i += uleb128enc(addr, block+i); newattr(die, DW_AT_location, DW_CLS_BLOCK, i, mal(i)); memmove(die->attr->data, block, i); } // Decoding the type.* symbols. This has to be in sync with // ../../pkg/runtime/type.go, or more specificaly, with what // ../gc/reflect.c stuffs in these. enum { KindBool = 1, KindInt, KindInt8, KindInt16, KindInt32, KindInt64, KindUint, KindUint8, KindUint16, KindUint32, KindUint64, KindUintptr, KindFloat32, KindFloat64, KindComplex64, KindComplex128, KindArray, KindChan, KindFunc, KindInterface, KindMap, KindPtr, KindSlice, KindString, KindStruct, KindUnsafePointer, KindNoPointers = 1<<7, // size of Type interface header + CommonType structure. CommonSize = 2*PtrSize+ 4*PtrSize + 8, }; static Reloc* decode_reloc(Sym *s, int32 off) { int i; for (i = 0; i < s->nr; i++) if (s->r[i].off == off) return s->r + i; return nil; } static Sym* decode_reloc_sym(Sym *s, int32 off) { Reloc *r; r = decode_reloc(s,off); if (r == nil) return nil; return r->sym; } static uvlong decode_inuxi(uchar* p, int sz) { uint64 v; uint32 l; uchar *cast, *inuxi; int i; v = l = 0; cast = nil; inuxi = nil; switch (sz) { case 2: cast = (uchar*)&l; inuxi = inuxi2; break; case 4: cast = (uchar*)&l; inuxi = inuxi4; break; case 8: cast = (uchar*)&v; inuxi = inuxi8; break; default: diag("dwarf: decode inuxi %d", sz); errorexit(); } for (i = 0; i < sz; i++) cast[inuxi[i]] = p[i]; if (sz == 8) return v; return l; } // Type.commonType.kind static uint8 decodetype_kind(Sym *s) { return s->p[3*PtrSize + 7] & ~KindNoPointers; // 0x13 / 0x1f } // Type.commonType.size static vlong decodetype_size(Sym *s) { return decode_inuxi(s->p + 2*PtrSize, PtrSize); // 0x8 / 0x10 } // Type.ArrayType.elem and Type.SliceType.Elem static Sym* decodetype_arrayelem(Sym *s) { return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30 } static vlong decodetype_arraylen(Sym *s) { return decode_inuxi(s->p + CommonSize+PtrSize, PtrSize); } // Type.PtrType.elem static Sym* decodetype_ptrelem(Sym *s) { return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30 } // Type.MapType.key, elem static Sym* decodetype_mapkey(Sym *s) { return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30 } static Sym* decodetype_mapvalue(Sym *s) { return decode_reloc_sym(s, CommonSize+PtrSize); // 0x20 / 0x38 } // Type.ChanType.elem static Sym* decodetype_chanelem(Sym *s) { return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30 } // Type.FuncType.dotdotdot static int decodetype_funcdotdotdot(Sym *s) { return s->p[CommonSize]; } // Type.FuncType.in.len static int decodetype_funcincount(Sym *s) { return decode_inuxi(s->p + CommonSize+2*PtrSize, 4); } static int decodetype_funcoutcount(Sym *s) { return decode_inuxi(s->p + CommonSize+3*PtrSize + 2*4, 4); } static Sym* decodetype_funcintype(Sym *s, int i) { Reloc *r; r = decode_reloc(s, CommonSize + PtrSize); if (r == nil) return nil; return decode_reloc_sym(r->sym, r->add + i * PtrSize); } static Sym* decodetype_funcouttype(Sym *s, int i) { Reloc *r; r = decode_reloc(s, CommonSize + 2*PtrSize + 2*4); if (r == nil) return nil; return decode_reloc_sym(r->sym, r->add + i * PtrSize); } // Type.StructType.fields.Slice::len static int decodetype_structfieldcount(Sym *s) { return decode_inuxi(s->p + CommonSize + PtrSize, 4); } enum { StructFieldSize = 5*PtrSize }; // Type.StructType.fields[]-> name, typ and offset. static char* decodetype_structfieldname(Sym *s, int i) { Reloc *r; // go.string."foo" 0x28 / 0x40 s = decode_reloc_sym(s, CommonSize + PtrSize + 2*4 + i*StructFieldSize); if (s == nil) // embedded structs have a nil name. return nil; r = decode_reloc(s, 0); // s has a pointer to the string data at offset 0 if (r == nil) // shouldn't happen. return nil; return (char*) r->sym->p + r->add; // the c-string } static Sym* decodetype_structfieldtype(Sym *s, int i) { return decode_reloc_sym(s, CommonSize + PtrSize + 2*4 + i*StructFieldSize + 2*PtrSize); } static vlong decodetype_structfieldoffs(Sym *s, int i) { return decode_inuxi(s->p + CommonSize + PtrSize + 2*4 + i*StructFieldSize + 4*PtrSize, 4); } // InterfaceTYpe.methods.len static vlong decodetype_ifacemethodcount(Sym *s) { return decode_inuxi(s->p + CommonSize + PtrSize, 4); } // Fake attributes for slices, maps and channel enum { DW_AT_internal_elem_type = 250, // channels and slices DW_AT_internal_key_type = 251, // maps DW_AT_internal_val_type = 252, // maps DW_AT_internal_location = 253, // params and locals }; static DWDie* defptrto(DWDie *dwtype); // below // Lookup predefined types static Sym* lookup_or_diag(char *n) { Sym *s; s = rlookup(n, 0); if (s == nil || s->size == 0) { diag("dwarf: missing type: %s", n); errorexit(); } return s; } // Define gotype, for composite ones recurse into constituents. static DWDie* defgotype(Sym *gotype) { DWDie *die, *fld; Sym *s; char *name, *f; uint8 kind; vlong bytesize; int i, nfields; if (gotype == nil) return find_or_diag(&dwtypes, ""); if (strncmp("type.", gotype->name, 5) != 0) { diag("dwarf: type name doesn't start with \".type\": %s", gotype->name); return find_or_diag(&dwtypes, ""); } name = gotype->name + 5; // could also decode from Type.string die = find(&dwtypes, name); if (die != nil) return die; if (0 && debug['v'] > 2) print("new type: %Y\n", gotype); kind = decodetype_kind(gotype); bytesize = decodetype_size(gotype); switch (kind) { case KindBool: die = newdie(&dwtypes, DW_ABRV_BASETYPE, name); newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_boolean, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindInt: case KindInt8: case KindInt16: case KindInt32: case KindInt64: die = newdie(&dwtypes, DW_ABRV_BASETYPE, name); newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_signed, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindUint: case KindUint8: case KindUint16: case KindUint32: case KindUint64: case KindUintptr: die = newdie(&dwtypes, DW_ABRV_BASETYPE, name); newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_unsigned, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindFloat32: case KindFloat64: die = newdie(&dwtypes, DW_ABRV_BASETYPE, name); newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_float, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindComplex64: case KindComplex128: die = newdie(&dwtypes, DW_ABRV_BASETYPE, name); newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_complex_float, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindArray: die = newdie(&dwtypes, DW_ABRV_ARRAYTYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); s = decodetype_arrayelem(gotype); newrefattr(die, DW_AT_type, defgotype(s)); fld = newdie(die, DW_ABRV_ARRAYRANGE, "range"); newattr(fld, DW_AT_upper_bound, DW_CLS_CONSTANT, decodetype_arraylen(gotype), 0); newrefattr(fld, DW_AT_type, find_or_diag(&dwtypes, "uintptr")); break; case KindChan: die = newdie(&dwtypes, DW_ABRV_CHANTYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); s = decodetype_chanelem(gotype); newrefattr(die, DW_AT_internal_elem_type, defgotype(s)); break; case KindFunc: die = newdie(&dwtypes, DW_ABRV_FUNCTYPE, name); newrefattr(die, DW_AT_type, find_or_diag(&dwtypes, "void")); nfields = decodetype_funcincount(gotype); for (i = 0; i < nfields; i++) { s = decodetype_funcintype(gotype, i); fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s->name+5); newrefattr(fld, DW_AT_type, defgotype(s)); } if (decodetype_funcdotdotdot(gotype)) newdie(die, DW_ABRV_DOTDOTDOT, "..."); nfields = decodetype_funcoutcount(gotype); for (i = 0; i < nfields; i++) { s = decodetype_funcouttype(gotype, i); fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s->name+5); newrefattr(fld, DW_AT_type, defptrto(defgotype(s))); } break; case KindInterface: die = newdie(&dwtypes, DW_ABRV_IFACETYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); nfields = decodetype_ifacemethodcount(gotype); if (nfields == 0) s = lookup_or_diag("type.runtime.eface"); else s = lookup_or_diag("type.runtime.iface"); newrefattr(die, DW_AT_type, defgotype(s)); break; case KindMap: die = newdie(&dwtypes, DW_ABRV_MAPTYPE, name); s = decodetype_mapkey(gotype); newrefattr(die, DW_AT_internal_key_type, defgotype(s)); s = decodetype_mapvalue(gotype); newrefattr(die, DW_AT_internal_val_type, defgotype(s)); break; case KindPtr: die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name); s = decodetype_ptrelem(gotype); newrefattr(die, DW_AT_type, defgotype(s)); break; case KindSlice: die = newdie(&dwtypes, DW_ABRV_SLICETYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); s = decodetype_arrayelem(gotype); newrefattr(die, DW_AT_internal_elem_type, defgotype(s)); break; case KindString: die = newdie(&dwtypes, DW_ABRV_STRINGTYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); break; case KindStruct: die = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, name); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0); nfields = decodetype_structfieldcount(gotype); for (i = 0; i < nfields; i++) { f = decodetype_structfieldname(gotype, i); s = decodetype_structfieldtype(gotype, i); if (f == nil) f = s->name + 5; // skip "type." fld = newdie(die, DW_ABRV_STRUCTFIELD, f); newrefattr(fld, DW_AT_type, defgotype(s)); newmemberoffsetattr(fld, decodetype_structfieldoffs(gotype, i)); } break; case KindUnsafePointer: die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name); newrefattr(die, DW_AT_type, find(&dwtypes, "void")); break; default: diag("dwarf: definition of unknown kind %d: %s", kind, gotype->name); die = newdie(&dwtypes, DW_ABRV_TYPEDECL, name); newrefattr(die, DW_AT_type, find_or_diag(&dwtypes, "")); } return die; } // Find or construct *T given T. static DWDie* defptrto(DWDie *dwtype) { char ptrname[1024]; DWDie *die; snprint(ptrname, sizeof ptrname, "*%s", getattr(dwtype, DW_AT_name)->data); die = find(&dwtypes, ptrname); if (die == nil) { die = newdie(&dwtypes, DW_ABRV_PTRTYPE, strcpy(mal(strlen(ptrname)+1), ptrname)); newrefattr(die, DW_AT_type, dwtype); } return die; } // Copies src's children into dst. Copies attributes by value. // DWAttr.data is copied as pointer only. static void copychildren(DWDie *dst, DWDie *src) { DWDie *c; DWAttr *a; for (src = src->child; src != nil; src = src->link) { c = newdie(dst, src->abbrev, getattr(src, DW_AT_name)->data); for (a = src->attr; a != nil; a = a->link) newattr(c, a->atr, a->cls, a->value, a->data); copychildren(c, src); } reverselist(&dst->child); } // Search children (assumed to have DW_TAG_member) for the one named // field and set its DW_AT_type to dwtype static void substitutetype(DWDie *structdie, char *field, DWDie* dwtype) { DWDie *child; DWAttr *a; child = find_or_diag(structdie, field); if (child == nil) return; a = getattr(child, DW_AT_type); if (a != nil) a->data = (char*) dwtype; else newrefattr(child, DW_AT_type, dwtype); } static void synthesizestringtypes(DWDie* die) { DWDie *prototype; prototype = defgotype(lookup_or_diag("type.runtime._string")); if (prototype == nil) return; for (; die != nil; die = die->link) { if (die->abbrev != DW_ABRV_STRINGTYPE) continue; copychildren(die, prototype); } } static void synthesizeslicetypes(DWDie *die) { DWDie *prototype, *elem; prototype = defgotype(lookup_or_diag("type.runtime.slice")); if (prototype == nil) return; for (; die != nil; die = die->link) { if (die->abbrev != DW_ABRV_SLICETYPE) continue; copychildren(die, prototype); elem = (DWDie*) getattr(die, DW_AT_internal_elem_type)->data; substitutetype(die, "array", defptrto(elem)); } } static char* mkinternaltypename(char *base, char *arg1, char *arg2) { char buf[1024]; char *n; if (arg2 == nil) snprint(buf, sizeof buf, "%s<%s>", base, arg1); else snprint(buf, sizeof buf, "%s<%s,%s>", base, arg1, arg2); n = mal(strlen(buf) + 1); memmove(n, buf, strlen(buf)); return n; } // synthesizemaptypes is way too closely married to runtime/hashmap.c enum { MaxValsize = 256 - 64 }; static void synthesizemaptypes(DWDie *die) { DWDie *hash, *hash_subtable, *hash_entry, *dwh, *dwhs, *dwhe, *dwhash, *keytype, *valtype, *fld; int hashsize, keysize, valsize, datsize, valsize_in_hash, datavo; DWAttr *a; hash = defgotype(lookup_or_diag("type.runtime.hmap")); hash_subtable = defgotype(lookup_or_diag("type.runtime.hash_subtable")); hash_entry = defgotype(lookup_or_diag("type.runtime.hash_entry")); if (hash == nil || hash_subtable == nil || hash_entry == nil) return; dwhash = (DWDie*)getattr(find_or_diag(hash_entry, "hash"), DW_AT_type)->data; if (dwhash == nil) return; hashsize = getattr(dwhash, DW_AT_byte_size)->value; for (; die != nil; die = die->link) { if (die->abbrev != DW_ABRV_MAPTYPE) continue; keytype = (DWDie*) getattr(die, DW_AT_internal_key_type)->data; valtype = (DWDie*) getattr(die, DW_AT_internal_val_type)->data; a = getattr(keytype, DW_AT_byte_size); keysize = a ? a->value : PtrSize; // We don't store size with Pointers a = getattr(valtype, DW_AT_byte_size); valsize = a ? a->value : PtrSize; // This is what happens in hash_init and makemap_c valsize_in_hash = valsize; if (valsize > MaxValsize) valsize_in_hash = PtrSize; datavo = keysize; if (valsize_in_hash >= PtrSize) datavo = rnd(keysize, PtrSize); datsize = datavo + valsize_in_hash; if (datsize < PtrSize) datsize = PtrSize; datsize = rnd(datsize, PtrSize); // Construct struct hash_entry dwhe = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("hash_entry", getattr(keytype, DW_AT_name)->data, getattr(valtype, DW_AT_name)->data)); fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "hash"); newrefattr(fld, DW_AT_type, dwhash); newmemberoffsetattr(fld, 0); fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "key"); newrefattr(fld, DW_AT_type, keytype); newmemberoffsetattr(fld, hashsize); fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "val"); if (valsize > MaxValsize) valtype = defptrto(valtype); newrefattr(fld, DW_AT_type, valtype); newmemberoffsetattr(fld, hashsize + datavo); newattr(dwhe, DW_AT_byte_size, DW_CLS_CONSTANT, hashsize + datsize, nil); // Construct hash_subtable> dwhs = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("hash_subtable", getattr(keytype, DW_AT_name)->data, getattr(valtype, DW_AT_name)->data)); copychildren(dwhs, hash_subtable); substitutetype(dwhs, "last", defptrto(dwhe)); substitutetype(dwhs, "entry", dwhe); // todo: []hash_entry with dynamic size newattr(dwhs, DW_AT_byte_size, DW_CLS_CONSTANT, getattr(hash_subtable, DW_AT_byte_size)->value, nil); // Construct hash dwh = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("hash", getattr(keytype, DW_AT_name)->data, getattr(valtype, DW_AT_name)->data)); copychildren(dwh, hash); substitutetype(dwh, "st", defptrto(dwhs)); newattr(dwh, DW_AT_byte_size, DW_CLS_CONSTANT, getattr(hash, DW_AT_byte_size)->value, nil); newrefattr(die, DW_AT_type, defptrto(dwh)); } } static void synthesizechantypes(DWDie *die) { DWDie *sudog, *waitq, *hchan, *dws, *dww, *dwh, *elemtype; DWAttr *a; int elemsize, sudogsize; sudog = defgotype(lookup_or_diag("type.runtime.sudog")); waitq = defgotype(lookup_or_diag("type.runtime.waitq")); hchan = defgotype(lookup_or_diag("type.runtime.hchan")); if (sudog == nil || waitq == nil || hchan == nil) return; sudogsize = getattr(sudog, DW_AT_byte_size)->value; for (; die != nil; die = die->link) { if (die->abbrev != DW_ABRV_CHANTYPE) continue; elemtype = (DWDie*) getattr(die, DW_AT_internal_elem_type)->data; a = getattr(elemtype, DW_AT_byte_size); elemsize = a ? a->value : PtrSize; // sudog dws = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("sudog", getattr(elemtype, DW_AT_name)->data, nil)); copychildren(dws, sudog); substitutetype(dws, "elem", elemtype); newattr(dws, DW_AT_byte_size, DW_CLS_CONSTANT, sudogsize + (elemsize > 8 ? elemsize - 8 : 0), nil); // waitq dww = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("waitq", getattr(elemtype, DW_AT_name)->data, nil)); copychildren(dww, waitq); substitutetype(dww, "first", defptrto(dws)); substitutetype(dww, "last", defptrto(dws)); newattr(dww, DW_AT_byte_size, DW_CLS_CONSTANT, getattr(waitq, DW_AT_byte_size)->value, nil); // hchan dwh = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, mkinternaltypename("hchan", getattr(elemtype, DW_AT_name)->data, nil)); copychildren(dwh, hchan); substitutetype(dwh, "recvq", dww); substitutetype(dwh, "sendq", dww); newattr(dwh, DW_AT_byte_size, DW_CLS_CONSTANT, getattr(hchan, DW_AT_byte_size)->value, nil); newrefattr(die, DW_AT_type, defptrto(dwh)); } } // For use with pass.c::genasmsym static void defdwsymb(Sym* sym, char *s, int t, vlong v, vlong size, int ver, Sym *gotype) { DWDie *dv, *dt; USED(size); if (strncmp(s, "go.string.", 10) == 0) return; if (strncmp(s, "type.", 5) == 0 && strcmp(s, "type.*") != 0) { defgotype(sym); return; } dv = nil; switch (t) { default: return; case 'd': case 'b': case 'D': case 'B': dv = newdie(&dwglobals, DW_ABRV_VARIABLE, s); newabslocexprattr(dv, v); if (ver == 0) newattr(dv, DW_AT_external, DW_CLS_FLAG, 1, 0); // fallthrough case 'a': case 'p': dt = defgotype(gotype); } if (dv != nil) newrefattr(dv, DW_AT_type, dt); } // TODO(lvd) For now, just append them all to the first compilation // unit (that should be main), in the future distribute them to the // appropriate compilation units. static void movetomodule(DWDie *parent) { DWDie *die; for (die = dwroot.child->child; die->link != nil; die = die->link) /* nix */; die->link = parent->child; } /* * Filename fragments for the line history stack. */ static char **ftab; static int ftabsize; void dwarfaddfrag(int n, char *frag) { int s; if (n >= ftabsize) { s = ftabsize; ftabsize = 1 + n + (n >> 2); ftab = realloc(ftab, ftabsize * sizeof(ftab[0])); memset(ftab + s, 0, (ftabsize - s) * sizeof(ftab[0])); } if (*frag == '<') frag++; ftab[n] = frag; } // Returns a malloc'ed string, piecewise copied from the ftab. static char * decodez(char *s) { int len, o; char *ss, *f; char *r, *rb, *re; len = 0; ss = s + 1; // first is 0 while((o = ((uint8)ss[0] << 8) | (uint8)ss[1]) != 0) { if (o < 0 || o >= ftabsize) { diag("dwarf: corrupt z entry"); return 0; } f = ftab[o]; if (f == nil) { diag("dwarf: corrupt z entry"); return 0; } len += strlen(f) + 1; // for the '/' ss += 2; } if (len == 0) return 0; r = malloc(len + 1); rb = r; re = rb + len + 1; s++; while((o = ((uint8)s[0] << 8) | (uint8)s[1]) != 0) { f = ftab[o]; if (rb == r || rb[-1] == '/') rb = seprint(rb, re, "%s", f); else rb = seprint(rb, re, "/%s", f); s += 2; } return r; } /* * The line history itself */ static char **histfile; // [0] holds "", DW_LNS_set_file arguments must be > 0. static int histfilesize; static int histfilecap; static void clearhistfile(void) { int i; // [0] holds "" for (i = 1; i < histfilesize; i++) free(histfile[i]); histfilesize = 0; } static int addhistfile(char *zentry) { char *fname; if (histfilesize == histfilecap) { histfilecap = 2 * histfilecap + 2; histfile = realloc(histfile, histfilecap * sizeof(char*)); } if (histfilesize == 0) histfile[histfilesize++] = ""; fname = decodez(zentry); // print("addhistfile %d: %s\n", histfilesize, fname); if (fname == 0) return -1; // Don't fill with duplicates (check only top one). if (strcmp(fname, histfile[histfilesize-1]) == 0) { free(fname); return histfilesize - 1; } histfile[histfilesize++] = fname; return histfilesize - 1; } // if the histfile stack contains ..../runtime/runtime_defs.go // use that to set gdbscript static void finddebugruntimepath(void) { int i, l; char *c; for (i = 1; i < histfilesize; i++) { if ((c = strstr(histfile[i], "runtime/runtime_defs.go")) != nil) { l = c - histfile[i]; memmove(gdbscript, histfile[i], l); memmove(gdbscript + l, "runtime/runtime-gdb.py", strlen("runtime/runtime-gdb.py") + 1); break; } } } // Go's runtime C sources are sane, and Go sources nest only 1 level, // so a handful would be plenty, if it weren't for the fact that line // directives can push an unlimited number of them. static struct { int file; vlong line; } *includestack; static int includestacksize; static int includetop; static vlong absline; typedef struct Linehist Linehist; struct Linehist { Linehist *link; vlong absline; vlong line; int file; }; static Linehist *linehist; static void checknesting(void) { if (includetop < 0) { diag("dwarf: corrupt z stack"); errorexit(); } if (includetop >= includestacksize) { includestacksize += 1; includestacksize <<= 2; // print("checknesting: growing to %d\n", includestacksize); includestack = realloc(includestack, includestacksize * sizeof *includestack); } } /* * Return false if the a->link chain contains no history, otherwise * returns true and finds z and Z entries in the Auto list (of a * Prog), and resets the history stack */ static int inithist(Auto *a) { Linehist *lh; for (; a; a = a->link) if (a->type == D_FILE) break; if (a==nil) return 0; // We have a new history. They are guaranteed to come completely // at the beginning of the compilation unit. if (a->aoffset != 1) { diag("dwarf: stray 'z' with offset %d", a->aoffset); return 0; } // Clear the history. clearhistfile(); includetop = 0; checknesting(); includestack[includetop].file = 0; includestack[includetop].line = -1; absline = 0; while (linehist != nil) { lh = linehist->link; free(linehist); linehist = lh; } // Construct the new one. for (; a; a = a->link) { if (a->type == D_FILE) { // 'z' int f = addhistfile(a->asym->name); if (f < 0) { // pop file includetop--; checknesting(); } else { // pushed a file (potentially same) includestack[includetop].line += a->aoffset - absline; includetop++; checknesting(); includestack[includetop].file = f; includestack[includetop].line = 1; } absline = a->aoffset; } else if (a->type == D_FILE1) { // 'Z' // We could just fixup the current // linehist->line, but there doesn't appear to // be a guarantee that every 'Z' is preceded // by its own 'z', so do the safe thing and // update the stack and push a new Linehist // entry includestack[includetop].line = a->aoffset; } else continue; if (linehist == 0 || linehist->absline != absline) { Linehist* lh = malloc(sizeof *lh); lh->link = linehist; lh->absline = absline; linehist = lh; } linehist->file = includestack[includetop].file; linehist->line = includestack[includetop].line; } return 1; } static Linehist * searchhist(vlong absline) { Linehist *lh; for (lh = linehist; lh; lh = lh->link) if (lh->absline <= absline) break; return lh; } static int guesslang(char *s) { if(strlen(s) >= 3 && strcmp(s+strlen(s)-3, ".go") == 0) return DW_LANG_Go; return DW_LANG_C; } /* * Generate short opcodes when possible, long ones when neccesary. * See section 6.2.5 */ enum { LINE_BASE = -1, LINE_RANGE = 4, OPCODE_BASE = 5 }; static void putpclcdelta(vlong delta_pc, vlong delta_lc) { if (LINE_BASE <= delta_lc && delta_lc < LINE_BASE+LINE_RANGE) { vlong opcode = OPCODE_BASE + (delta_lc - LINE_BASE) + (LINE_RANGE * delta_pc); if (OPCODE_BASE <= opcode && opcode < 256) { cput(opcode); return; } } if (delta_pc) { cput(DW_LNS_advance_pc); sleb128put(delta_pc); } cput(DW_LNS_advance_line); sleb128put(delta_lc); cput(DW_LNS_copy); } static void newcfaoffsetattr(DWDie *die, int32 offs) { char block[10]; int i; i = 0; block[i++] = DW_OP_call_frame_cfa; if (offs != 0) { block[i++] = DW_OP_consts; i += sleb128enc(offs, block+i); block[i++] = DW_OP_plus; } newattr(die, DW_AT_location, DW_CLS_BLOCK, i, mal(i)); memmove(die->attr->data, block, i); } static char* mkvarname(char* name, int da) { char buf[1024]; char *n; snprint(buf, sizeof buf, "%s#%d", name, da); n = mal(strlen(buf) + 1); memmove(n, buf, strlen(buf)); return n; } /* * Walk prog table, emit line program and build DIE tree. */ // flush previous compilation unit. static void flushunit(DWDie *dwinfo, vlong pc, vlong unitstart, int32 header_length) { vlong here; if (dwinfo != nil && pc != 0) { newattr(dwinfo, DW_AT_high_pc, DW_CLS_ADDRESS, pc+1, 0); } if (unitstart >= 0) { cput(0); // start extended opcode uleb128put(1); cput(DW_LNE_end_sequence); here = cpos(); cseek(unitstart); LPUT(here - unitstart - sizeof(int32)); // unit_length WPUT(3); // dwarf version LPUT(header_length); // header length starting here cseek(here); } } static void writelines(void) { Prog *q; Sym *s; Auto *a; vlong unitstart, headerend, offs; vlong pc, epc, lc, llc, lline; int currfile; int i, lang, da, dt; Linehist *lh; DWDie *dwinfo, *dwfunc, *dwvar, **dws; DWDie *varhash[HASHSIZE]; char *n, *nn; unitstart = -1; headerend = -1; pc = 0; epc = 0; lc = 1; llc = 1; currfile = -1; lineo = cpos(); dwinfo = nil; for(cursym = textp; cursym != nil; cursym = cursym->next) { s = cursym; if(s->text == P) continue; // Look for history stack. If we find one, // we're entering a new compilation unit if (inithist(s->autom)) { flushunit(dwinfo, epc, unitstart, headerend - unitstart - 10); unitstart = cpos(); if(debug['v'] > 1) { print("dwarf writelines found %s\n", histfile[1]); Linehist* lh; for (lh = linehist; lh; lh = lh->link) print("\t%8lld: [%4lld]%s\n", lh->absline, lh->line, histfile[lh->file]); } lang = guesslang(histfile[1]); finddebugruntimepath(); dwinfo = newdie(&dwroot, DW_ABRV_COMPUNIT, strdup(histfile[1])); newattr(dwinfo, DW_AT_language, DW_CLS_CONSTANT,lang, 0); newattr(dwinfo, DW_AT_stmt_list, DW_CLS_PTR, unitstart - lineo, 0); newattr(dwinfo, DW_AT_low_pc, DW_CLS_ADDRESS, s->text->pc, 0); // Write .debug_line Line Number Program Header (sec 6.2.4) // Fields marked with (*) must be changed for 64-bit dwarf LPUT(0); // unit_length (*), will be filled in by flushunit. WPUT(3); // dwarf version (appendix F) LPUT(0); // header_length (*), filled in by flushunit. // cpos == unitstart + 4 + 2 + 4 cput(1); // minimum_instruction_length cput(1); // default_is_stmt cput(LINE_BASE); // line_base cput(LINE_RANGE); // line_range cput(OPCODE_BASE); // opcode_base (we only use 1..4) cput(0); // standard_opcode_lengths[1] cput(1); // standard_opcode_lengths[2] cput(1); // standard_opcode_lengths[3] cput(1); // standard_opcode_lengths[4] cput(0); // include_directories (empty) for (i=1; i < histfilesize; i++) { strnput(histfile[i], strlen(histfile[i]) + 4); // 4 zeros: the string termination + 3 fields. } cput(0); // terminate file_names. headerend = cpos(); pc = s->text->pc; epc = pc; currfile = 1; lc = 1; llc = 1; cput(0); // start extended opcode uleb128put(1 + PtrSize); cput(DW_LNE_set_address); addrput(pc); } if(s->text == nil) continue; if (unitstart < 0) { diag("dwarf: reachable code before seeing any history: %P", s->text); continue; } dwfunc = newdie(dwinfo, DW_ABRV_FUNCTION, s->name); newattr(dwfunc, DW_AT_low_pc, DW_CLS_ADDRESS, s->value, 0); epc = s->value + s->size; newattr(dwfunc, DW_AT_high_pc, DW_CLS_ADDRESS, epc, 0); if (s->version == 0) newattr(dwfunc, DW_AT_external, DW_CLS_FLAG, 1, 0); if(s->text->link == nil) continue; for(q = s->text; q != P; q = q->link) { lh = searchhist(q->line); if (lh == nil) { diag("dwarf: corrupt history or bad absolute line: %P", q); continue; } if (lh->file < 1) { // 0 is the past-EOF entry. // diag("instruction with line number past EOF in %s: %P", histfile[1], q); continue; } lline = lh->line + q->line - lh->absline; if (debug['v'] > 1) print("%6llux %s[%lld] %P\n", (vlong)q->pc, histfile[lh->file], lline, q); if (q->line == lc) continue; if (currfile != lh->file) { currfile = lh->file; cput(DW_LNS_set_file); uleb128put(currfile); } putpclcdelta(q->pc - pc, lline - llc); pc = q->pc; lc = q->line; llc = lline; } da = 0; dwfunc->hash = varhash; // enable indexing of children by name memset(varhash, 0, sizeof varhash); for(a = s->autom; a; a = a->link) { switch (a->type) { case D_AUTO: dt = DW_ABRV_AUTO; offs = a->aoffset - PtrSize; break; case D_PARAM: dt = DW_ABRV_PARAM; offs = a->aoffset; break; default: continue; } if (strstr(a->asym->name, ".autotmp_")) continue; if (find(dwfunc, a->asym->name) != nil) n = mkvarname(a->asym->name, da); else n = a->asym->name; // Drop the package prefix from locals and arguments. nn = strrchr(n, '.'); if (nn) n = nn + 1; dwvar = newdie(dwfunc, dt, n); newcfaoffsetattr(dwvar, offs); newrefattr(dwvar, DW_AT_type, defgotype(a->gotype)); // push dwvar down dwfunc->child to preserve order newattr(dwvar, DW_AT_internal_location, DW_CLS_CONSTANT, offs, nil); dwfunc->child = dwvar->link; // take dwvar out from the top of the list for (dws = &dwfunc->child; *dws != nil; dws = &(*dws)->link) if (offs > getattr(*dws, DW_AT_internal_location)->value) break; dwvar->link = *dws; *dws = dwvar; da++; } dwfunc->hash = nil; } flushunit(dwinfo, epc, unitstart, headerend - unitstart - 10); linesize = cpos() - lineo; } /* * Emit .debug_frame */ enum { CIERESERVE = 16, DATAALIGNMENTFACTOR = -4, // TODO -PtrSize? FAKERETURNCOLUMN = 16 // TODO gdb6 doesnt like > 15? }; static void putpccfadelta(vlong deltapc, vlong cfa) { if (deltapc < 0x40) { cput(DW_CFA_advance_loc + deltapc); } else if (deltapc < 0x100) { cput(DW_CFA_advance_loc1); cput(deltapc); } else if (deltapc < 0x10000) { cput(DW_CFA_advance_loc2); WPUT(deltapc); } else { cput(DW_CFA_advance_loc4); LPUT(deltapc); } cput(DW_CFA_def_cfa_offset_sf); sleb128put(cfa / DATAALIGNMENTFACTOR); } static void writeframes(void) { Prog *p, *q; Sym *s; vlong fdeo, fdesize, pad, cfa, pc; frameo = cpos(); // Emit the CIE, Section 6.4.1 LPUT(CIERESERVE); // initial length, must be multiple of PtrSize LPUT(0xffffffff); // cid. cput(3); // dwarf version (appendix F) cput(0); // augmentation "" uleb128put(1); // code_alignment_factor sleb128put(DATAALIGNMENTFACTOR); // guess uleb128put(FAKERETURNCOLUMN); // return_address_register cput(DW_CFA_def_cfa); uleb128put(DWARFREGSP); // register SP (**ABI-dependent, defined in l.h) uleb128put(PtrSize); // offset cput(DW_CFA_offset + FAKERETURNCOLUMN); // return address uleb128put(-PtrSize / DATAALIGNMENTFACTOR); // at cfa - x*4 // 4 is to exclude the length field. pad = CIERESERVE + frameo + 4 - cpos(); if (pad < 0) { diag("dwarf: CIERESERVE too small by %lld bytes.", -pad); errorexit(); } strnput("", pad); for(cursym = textp; cursym != nil; cursym = cursym->next) { s = cursym; if(s->text == nil) continue; fdeo = cpos(); // Emit a FDE, Section 6.4.1, starting wit a placeholder. LPUT(0); // length, must be multiple of PtrSize LPUT(0); // Pointer to the CIE above, at offset 0 addrput(0); // initial location addrput(0); // address range cfa = PtrSize; // CFA starts at sp+PtrSize p = s->text; pc = p->pc; for(q = p; q->link != P; q = q->link) { if (q->spadj == 0) continue; cfa += q->spadj; putpccfadelta(q->link->pc - pc, cfa); pc = q->link->pc; } fdesize = cpos() - fdeo - 4; // exclude the length field. pad = rnd(fdesize, PtrSize) - fdesize; strnput("", pad); fdesize += pad; // Emit the FDE header for real, Section 6.4.1. cseek(fdeo); LPUT(fdesize); LPUT(0); addrput(p->pc); addrput(s->size); cseek(fdeo + 4 + fdesize); } cflush(); framesize = cpos() - frameo; } /* * Walk DWarfDebugInfoEntries, and emit .debug_info */ enum { COMPUNITHEADERSIZE = 4+2+4+1 }; static void writeinfo(void) { DWDie *compunit; vlong unitstart, here; fwdcount = 0; for (compunit = dwroot.child; compunit; compunit = compunit->link) { unitstart = cpos(); // Write .debug_info Compilation Unit Header (sec 7.5.1) // Fields marked with (*) must be changed for 64-bit dwarf // This must match COMPUNITHEADERSIZE above. LPUT(0); // unit_length (*), will be filled in later. WPUT(3); // dwarf version (appendix F) LPUT(0); // debug_abbrev_offset (*) cput(PtrSize); // address_size putdie(compunit); here = cpos(); cseek(unitstart); LPUT(here - unitstart - 4); // exclude the length field. cseek(here); } cflush(); } /* * Emit .debug_pubnames/_types. _info must have been written before, * because we need die->offs and infoo/infosize; */ static int ispubname(DWDie *die) { DWAttr *a; switch(die->abbrev) { case DW_ABRV_FUNCTION: case DW_ABRV_VARIABLE: a = getattr(die, DW_AT_external); return a && a->value; } return 0; } static int ispubtype(DWDie *die) { return die->abbrev >= DW_ABRV_NULLTYPE; } static vlong writepub(int (*ispub)(DWDie*)) { DWDie *compunit, *die; DWAttr *dwa; vlong unitstart, unitend, sectionstart, here; sectionstart = cpos(); for (compunit = dwroot.child; compunit != nil; compunit = compunit->link) { unitstart = compunit->offs - COMPUNITHEADERSIZE; if (compunit->link != nil) unitend = compunit->link->offs - COMPUNITHEADERSIZE; else unitend = infoo + infosize; // Write .debug_pubnames/types Header (sec 6.1.1) LPUT(0); // unit_length (*), will be filled in later. WPUT(2); // dwarf version (appendix F) LPUT(unitstart); // debug_info_offset (of the Comp unit Header) LPUT(unitend - unitstart); // debug_info_length for (die = compunit->child; die != nil; die = die->link) { if (!ispub(die)) continue; LPUT(die->offs - unitstart); dwa = getattr(die, DW_AT_name); strnput(dwa->data, dwa->value + 1); } LPUT(0); here = cpos(); cseek(sectionstart); LPUT(here - sectionstart - 4); // exclude the length field. cseek(here); } return sectionstart; } /* * emit .debug_aranges. _info must have been written before, * because we need die->offs of dw_globals. */ static vlong writearanges(void) { DWDie *compunit; DWAttr *b, *e; int headersize; vlong sectionstart; sectionstart = cpos(); headersize = rnd(4+2+4+1+1, PtrSize); // don't count unit_length field itself for (compunit = dwroot.child; compunit != nil; compunit = compunit->link) { b = getattr(compunit, DW_AT_low_pc); if (b == nil) continue; e = getattr(compunit, DW_AT_high_pc); if (e == nil) continue; // Write .debug_aranges Header + entry (sec 6.1.2) LPUT(headersize + 4*PtrSize - 4); // unit_length (*) WPUT(2); // dwarf version (appendix F) LPUT(compunit->offs - COMPUNITHEADERSIZE); // debug_info_offset cput(PtrSize); // address_size cput(0); // segment_size strnput("", headersize - (4+2+4+1+1)); // align to PtrSize addrput(b->value); addrput(e->value - b->value); addrput(0); addrput(0); } cflush(); return sectionstart; } static vlong writegdbscript(void) { vlong sectionstart; sectionstart = cpos(); if (gdbscript[0]) { cput(1); // magic 1 byte? strnput(gdbscript, strlen(gdbscript)+1); cflush(); } return sectionstart; } static void align(vlong size) { if(HEADTYPE == Hwindows) // Only Windows PE need section align. strnput("", rnd(size, PEFILEALIGN) - size); } /* * This is the main entry point for generating dwarf. After emitting * the mandatory debug_abbrev section, it calls writelines() to set up * the per-compilation unit part of the DIE tree, while simultaneously * emitting the debug_line section. When the final tree contains * forward references, it will write the debug_info section in 2 * passes. * */ void dwarfemitdebugsections(void) { vlong infoe; DWDie* die; if(debug['w']) // disable dwarf return; // For diagnostic messages. newattr(&dwtypes, DW_AT_name, DW_CLS_STRING, strlen("dwtypes"), "dwtypes"); mkindex(&dwroot); mkindex(&dwtypes); mkindex(&dwglobals); // Some types that must exist to define other ones. newdie(&dwtypes, DW_ABRV_NULLTYPE, ""); newdie(&dwtypes, DW_ABRV_NULLTYPE, "void"); newrefattr(newdie(&dwtypes, DW_ABRV_PTRTYPE, "unsafe.Pointer"), DW_AT_type, find(&dwtypes, "void")); die = newdie(&dwtypes, DW_ABRV_BASETYPE, "uintptr"); // needed for array size newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_unsigned, 0); newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, PtrSize, 0); // Needed by the prettyprinter code for interface inspection. defgotype(lookup_or_diag("type.runtime.commonType")); defgotype(lookup_or_diag("type.runtime.InterfaceType")); defgotype(lookup_or_diag("type.runtime.itab")); genasmsym(defdwsymb); writeabbrev(); align(abbrevsize); writelines(); align(linesize); writeframes(); align(framesize); synthesizestringtypes(dwtypes.child); synthesizeslicetypes(dwtypes.child); synthesizemaptypes(dwtypes.child); synthesizechantypes(dwtypes.child); reversetree(&dwroot.child); reversetree(&dwtypes.child); reversetree(&dwglobals.child); movetomodule(&dwtypes); movetomodule(&dwglobals); infoo = cpos(); writeinfo(); infoe = cpos(); pubnameso = infoe; pubtypeso = infoe; arangeso = infoe; gdbscripto = infoe; if (fwdcount > 0) { if (debug['v']) Bprint(&bso, "%5.2f dwarf pass 2.\n", cputime()); cseek(infoo); writeinfo(); if (fwdcount > 0) { diag("dwarf: unresolved references after first dwarf info pass"); errorexit(); } if (infoe != cpos()) { diag("dwarf: inconsistent second dwarf info pass"); errorexit(); } } infosize = infoe - infoo; align(infosize); pubnameso = writepub(ispubname); pubnamessize = cpos() - pubnameso; align(pubnamessize); pubtypeso = writepub(ispubtype); pubtypessize = cpos() - pubtypeso; align(pubtypessize); arangeso = writearanges(); arangessize = cpos() - arangeso; align(arangessize); gdbscripto = writegdbscript(); gdbscriptsize = cpos() - gdbscripto; align(gdbscriptsize); } /* * Elf. */ enum { ElfStrDebugAbbrev, ElfStrDebugAranges, ElfStrDebugFrame, ElfStrDebugInfo, ElfStrDebugLine, ElfStrDebugLoc, ElfStrDebugMacinfo, ElfStrDebugPubNames, ElfStrDebugPubTypes, ElfStrDebugRanges, ElfStrDebugStr, ElfStrGDBScripts, NElfStrDbg }; vlong elfstrdbg[NElfStrDbg]; void dwarfaddshstrings(Sym *shstrtab) { if(debug['w']) // disable dwarf return; elfstrdbg[ElfStrDebugAbbrev] = addstring(shstrtab, ".debug_abbrev"); elfstrdbg[ElfStrDebugAranges] = addstring(shstrtab, ".debug_aranges"); elfstrdbg[ElfStrDebugFrame] = addstring(shstrtab, ".debug_frame"); elfstrdbg[ElfStrDebugInfo] = addstring(shstrtab, ".debug_info"); elfstrdbg[ElfStrDebugLine] = addstring(shstrtab, ".debug_line"); elfstrdbg[ElfStrDebugLoc] = addstring(shstrtab, ".debug_loc"); elfstrdbg[ElfStrDebugMacinfo] = addstring(shstrtab, ".debug_macinfo"); elfstrdbg[ElfStrDebugPubNames] = addstring(shstrtab, ".debug_pubnames"); elfstrdbg[ElfStrDebugPubTypes] = addstring(shstrtab, ".debug_pubtypes"); elfstrdbg[ElfStrDebugRanges] = addstring(shstrtab, ".debug_ranges"); elfstrdbg[ElfStrDebugStr] = addstring(shstrtab, ".debug_str"); elfstrdbg[ElfStrGDBScripts] = addstring(shstrtab, ".debug_gdb_scripts"); } void dwarfaddelfheaders(void) { ElfShdr *sh; if(debug['w']) // disable dwarf return; sh = newElfShdr(elfstrdbg[ElfStrDebugAbbrev]); sh->type = SHT_PROGBITS; sh->off = abbrevo; sh->size = abbrevsize; sh->addralign = 1; sh = newElfShdr(elfstrdbg[ElfStrDebugLine]); sh->type = SHT_PROGBITS; sh->off = lineo; sh->size = linesize; sh->addralign = 1; sh = newElfShdr(elfstrdbg[ElfStrDebugFrame]); sh->type = SHT_PROGBITS; sh->off = frameo; sh->size = framesize; sh->addralign = 1; sh = newElfShdr(elfstrdbg[ElfStrDebugInfo]); sh->type = SHT_PROGBITS; sh->off = infoo; sh->size = infosize; sh->addralign = 1; if (pubnamessize > 0) { sh = newElfShdr(elfstrdbg[ElfStrDebugPubNames]); sh->type = SHT_PROGBITS; sh->off = pubnameso; sh->size = pubnamessize; sh->addralign = 1; } if (pubtypessize > 0) { sh = newElfShdr(elfstrdbg[ElfStrDebugPubTypes]); sh->type = SHT_PROGBITS; sh->off = pubtypeso; sh->size = pubtypessize; sh->addralign = 1; } if (arangessize) { sh = newElfShdr(elfstrdbg[ElfStrDebugAranges]); sh->type = SHT_PROGBITS; sh->off = arangeso; sh->size = arangessize; sh->addralign = 1; } if (gdbscriptsize) { sh = newElfShdr(elfstrdbg[ElfStrGDBScripts]); sh->type = SHT_PROGBITS; sh->off = gdbscripto; sh->size = gdbscriptsize; sh->addralign = 1; } } /* * Macho */ void dwarfaddmachoheaders(void) { MachoSect *msect; MachoSeg *ms; vlong fakestart; int nsect; if(debug['w']) // disable dwarf return; // Zero vsize segments won't be loaded in memory, even so they // have to be page aligned in the file. fakestart = abbrevo & ~0xfff; nsect = 4; if (pubnamessize > 0) nsect++; if (pubtypessize > 0) nsect++; if (arangessize > 0) nsect++; if (gdbscriptsize > 0) nsect++; ms = newMachoSeg("__DWARF", nsect); ms->fileoffset = fakestart; ms->filesize = abbrevo-fakestart; msect = newMachoSect(ms, "__debug_abbrev"); msect->off = abbrevo; msect->size = abbrevsize; ms->filesize += msect->size; msect = newMachoSect(ms, "__debug_line"); msect->off = lineo; msect->size = linesize; ms->filesize += msect->size; msect = newMachoSect(ms, "__debug_frame"); msect->off = frameo; msect->size = framesize; ms->filesize += msect->size; msect = newMachoSect(ms, "__debug_info"); msect->off = infoo; msect->size = infosize; ms->filesize += msect->size; if (pubnamessize > 0) { msect = newMachoSect(ms, "__debug_pubnames"); msect->off = pubnameso; msect->size = pubnamessize; ms->filesize += msect->size; } if (pubtypessize > 0) { msect = newMachoSect(ms, "__debug_pubtypes"); msect->off = pubtypeso; msect->size = pubtypessize; ms->filesize += msect->size; } if (arangessize > 0) { msect = newMachoSect(ms, "__debug_aranges"); msect->off = arangeso; msect->size = arangessize; ms->filesize += msect->size; } // TODO(lvd) fix gdb/python to load MachO (16 char section name limit) if (gdbscriptsize > 0) { msect = newMachoSect(ms, "__debug_gdb_scripts"); msect->off = gdbscripto; msect->size = gdbscriptsize; ms->filesize += msect->size; } } /* * Windows PE */ void dwarfaddpeheaders(void) { if(debug['w']) // disable dwarf return; newPEDWARFSection(".debug_abbrev", abbrevsize); newPEDWARFSection(".debug_line", linesize); newPEDWARFSection(".debug_frame", framesize); newPEDWARFSection(".debug_info", infosize); newPEDWARFSection(".debug_pubnames", pubnamessize); newPEDWARFSection(".debug_pubtypes", pubtypessize); newPEDWARFSection(".debug_aranges", arangessize); newPEDWARFSection(".debug_gdb_scripts", gdbscriptsize); }