code review 116720043: cmd/ld: add go-specific dwarf type information

src/cmd/ld/dwarf.c

 // 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
@@ skipping 123 matching lines @@
 {
         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 attributes 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;
+        uint16 attr;
         uint8 form;
+};
+
+// Go-specific type attributes.
+enum {
+        DW_AT_go_kind = 0x2900,
+        DW_AT_go_key = 0x2901,
+        DW_AT_go_elem = 0x2902,
+
+        DW_AT_internal_location = 253,   // params and locals; not emitted
 };
 
 // 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,
@@ skipping 108 matching lines @@
                 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,
+                DW_AT_go_kind, 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,
+                DW_AT_go_kind, DW_FORM_data1,
                 0, 0
         },
 
         /* CHANTYPE */
         {
                 DW_TAG_typedef, DW_CHILDREN_no,
                 DW_AT_name,     DW_FORM_string,
                 DW_AT_type,     DW_FORM_ref_addr,
+                DW_AT_go_kind, DW_FORM_data1,
+                DW_AT_go_elem, 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,
+                DW_AT_go_kind, DW_FORM_data1,
                 0, 0
         },
 
         /* IFACETYPE */
         {
                 DW_TAG_typedef, DW_CHILDREN_yes,
                 DW_AT_name,      DW_FORM_string,
                 DW_AT_type,     DW_FORM_ref_addr,
+                DW_AT_go_kind, DW_FORM_data1,
                 0, 0
         },
 
         /* MAPTYPE */
         {
                 DW_TAG_typedef, DW_CHILDREN_no,
                 DW_AT_name,     DW_FORM_string,
                 DW_AT_type,     DW_FORM_ref_addr,
+                DW_AT_go_kind, DW_FORM_data1,
+                DW_AT_go_key, DW_FORM_ref_addr,
+                DW_AT_go_elem, 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,
+                DW_AT_go_kind, DW_FORM_data1,
                 0, 0
         },
         /* BARE_PTRTYPE */
         {
                 DW_TAG_pointer_type, DW_CHILDREN_no,
                 DW_AT_name,     DW_FORM_string,
                 0, 0
         },
 
         /* SLICETYPE */
         {
                 DW_TAG_structure_type, DW_CHILDREN_yes,
                 DW_AT_name,     DW_FORM_string,
                 DW_AT_byte_size, DW_FORM_udata,
+                DW_AT_go_kind, DW_FORM_data1,
+                DW_AT_go_elem, DW_FORM_ref_addr,
                 0, 0
         },
 
         /* STRINGTYPE */
         {
                 DW_TAG_structure_type, DW_CHILDREN_yes,
                 DW_AT_name,     DW_FORM_string,
                 DW_AT_byte_size, DW_FORM_udata,
+                DW_AT_go_kind, DW_FORM_data1,
                 0, 0
         },
 
         /* STRUCTTYPE */
         {
                 DW_TAG_structure_type, DW_CHILDREN_yes,
                 DW_AT_name,     DW_FORM_string,
                 DW_AT_byte_size, DW_FORM_udata,
+                DW_AT_go_kind, DW_FORM_data1,
                 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;
+        int i, j;
+        DWAttrForm *f;
 
         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));
+                for(j=0; j<nelem(abbrevs[i].attr); j++) {
+                        f = &abbrevs[i].attr[j];
+                        uleb128put(f->attr);
+                        uleb128put(f->form);
+                        if(f->attr == 0)
+                                break;
+                }
         }
         cput(0);
         abbrevsize = cpos() - abbrevo;
 }
 
 /*
  * Debugging Information Entries and their attributes.
  */
 
 enum
@@ skipping 13 matching lines @@
 }
 
 // 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_
+        uint16 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)
+newattr(DWDie *die, uint16 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)
+getattr(DWDie *die, uint16 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) {
@@ skipping 138 matching lines @@
         case 8:
                 VPUT(addend);
                 break;
         default:
                 diag("bad size in adddwarfrel");
                 break;
         }
 }
 
 static DWAttr*
-newrefattr(DWDie *die, uint8 attr, DWDie* ref)
+newrefattr(DWDie *die, uint16 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 abbrev, int form, int cls, vlong value, char *data)
@@ skipping 119 matching lines @@
                 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(abbrev, af->form,
-                                attrs[af->attr]->cls,
-                                attrs[af->attr]->value,
-                                attrs[af->attr]->data);
-                else
-                        putattr(abbrev, af->form, 0, 0, nil);
+        DWAttr *ap;
+
+        for(af = abbrevs[abbrev].attr; af->attr; af++) {
+                for(ap=attr; ap; ap=ap->link) {
+                        if(ap->atr == af->attr) {
+                                putattr(abbrev, af->form,
+                                        ap->cls,
+                                        ap->value,
+                                        ap->data);
+                                goto done;
+                        }
+                }
+                putattr(abbrev, af->form, 0, 0, nil);
+        done:;
+        }
 }
 
 static void putdie(DWDie* die);
 
 static void
 putdies(DWDie* die)
 {
         for(; die; die = die->link)
                 putdie(die);
 }
@@ skipping 50 matching lines @@
         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, LSym *sym)
 {
         newattr(die, DW_AT_location, DW_CLS_ADDRESS, addr, (char*)sym);
 }
-
-
-// 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 LSym*
 lookup_or_diag(char *n)
 {
         LSym *s;
 
         s = linkrlookup(ctxt, n, 0);
@@ skipping 109 matching lines @@
                 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));
+                newrefattr(die, DW_AT_go_elem, defgotype(s));
                 break;
 
         case KindFunc:
                 die = newdie(&dwtypes, DW_ABRV_FUNCTYPE, name);
                 dotypedef(&dwtypes, name, die);
                 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);
@@ skipping 17 matching lines @@
                 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));
+                newrefattr(die, DW_AT_go_key, defgotype(s));
                 s = decodetype_mapvalue(gotype);
-                newrefattr(die, DW_AT_internal_val_type, defgotype(s));
+                newrefattr(die, DW_AT_go_elem, defgotype(s));
                 break;
 
         case KindPtr:
                 die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name);
                 dotypedef(&dwtypes, name, die);
                 s = decodetype_ptrelem(gotype);
                 newrefattr(die, DW_AT_type, defgotype(s));
                 break;
 
         case KindSlice:
                 die = newdie(&dwtypes, DW_ABRV_SLICETYPE, name);
                 dotypedef(&dwtypes, name, die);
                 newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
                 s = decodetype_arrayelem(gotype);
-                newrefattr(die, DW_AT_internal_elem_type, defgotype(s));
+                newrefattr(die, DW_AT_go_elem, 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);
                 dotypedef(&dwtypes, name, die);
@@ skipping 11 matching lines @@
                 break;
 
         case KindUnsafePointer:
                 die = newdie(&dwtypes, DW_ABRV_BARE_PTRTYPE, name);
                 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, "<unspecified>"));
-         }
+        }
+
+        newattr(die, DW_AT_go_kind, DW_CLS_CONSTANT, kind, 0);
 
         return die;
 }
 
 // Find or construct *T given T.
 static DWDie*
 defptrto(DWDie *dwtype)
 {
         char ptrname[1024];
         DWDie *die;
@@ skipping 74 matching lines @@
         DWDie *prototype, *elem;
 
         prototype = walktypedef(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;
+                elem = (DWDie*) getattr(die, DW_AT_go_elem)->data;
                 substitutetype(die, "array", defptrto(elem));
         }
 }
 
 static char*
 mkinternaltypename(char *base, char *arg1, char *arg2)
 {
         char buf[1024];
         char *n;
 
@@ skipping 25 matching lines @@
         hash            = walktypedef(defgotype(lookup_or_diag("type.runtime.hmap")));
         bucket          = walktypedef(defgotype(lookup_or_diag("type.runtime.bucket")));
 
         if (hash == nil)
                 return;
 
         for (; die != nil; die = die->link) {
                 if (die->abbrev != DW_ABRV_MAPTYPE)
                         continue;
 
-                keytype = walktypedef((DWDie*) getattr(die, DW_AT_internal_key_type)->data);
-                valtype = walktypedef((DWDie*) getattr(die, DW_AT_internal_val_type)->data);
+                keytype = walktypedef((DWDie*) getattr(die, DW_AT_go_key)->data);
+                valtype = walktypedef((DWDie*) getattr(die, DW_AT_go_elem)->data);
 
                 // compute size info like hashmap.c does.
                 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;
                 indirect_key = 0;
                 indirect_val = 0;
                 if(keysize > MaxKeySize) {
                         keysize = PtrSize;
@@ skipping 70 matching lines @@
         waitq = walktypedef(defgotype(lookup_or_diag("type.runtime.waitq")));
         hchan = walktypedef(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;
+                elemtype = (DWDie*) getattr(die, DW_AT_go_elem)->data;
                 a = getattr(elemtype, DW_AT_byte_size);
                 elemsize = a ? a->value : PtrSize;
 
                 // sudog<T>
                 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,
@@ skipping 698 matching lines @@
         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, "<unspecified>");
         newdie(&dwtypes, DW_ABRV_NULLTYPE, "void");
         newdie(&dwtypes, DW_ABRV_BARE_PTRTYPE, "unsafe.Pointer");
+
         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);
+        newattr(die, DW_AT_go_kind, DW_CLS_CONSTANT, KindUintptr, 0);
 
         // Needed by the prettyprinter code for interface inspection.
         defgotype(lookup_or_diag("type.runtime.rtype"));
         defgotype(lookup_or_diag("type.runtime.interfaceType"));
         defgotype(lookup_or_diag("type.runtime.itab"));
 
         genasmsym(defdwsymb);
 
         writeabbrev();
         align(abbrevsize);
@@ skipping 380 matching lines @@
 
         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);
 }