code review 4047047: runtime: automaticaly generated Go declarations for C v...

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
 //   - (upstream) type info for C parts of runtime
 //   - gdb uses c syntax, meaning clumsy quoting is needed for go identifiers. eg
@@ skipping 972 matching lines @@
 // 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) {

[rsc, 2011/01/26 17:11:26]

\n before {

+        Sym *s;
+
+        s = lookup(n,0);

[rsc, 2011/01/26 17:11:26]

s/,/, /

+        if (s->size == 0)
+                diag("missing type:%s", n);

[rsc, 2011/01/26 17:11:26]

s/:/: /
s/missing/dwarf: missing

if the caller is going to crash (and it looks like it will)
then maybe this should next call 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, "<unspecified>");
 
         if (strncmp("type.", gotype->name, 5) != 0) {
                 diag("Type name doesn't start with \".type\": %s", gotype->name);
                 return find_or_diag(&dwtypes, "<unspecified>");
         }
-        name = gotype->name + 5;  // Altenatively decode from Type.string
+        name = gotype->name + 5;  // Alternatively decode from Type.string

[rsc, 2011/01/26 17:11:26]

s/Alternatively/could also/

 
         die = find(&dwtypes, name);
         if (die != nil)
                 return die;
 
-        if (0 && debug['v'] > 2) {
+        if (1 && debug['v'] > 2) {

[rsc, 2011/01/26 17:11:26]

s/1/0/

                 print("new type: %s @0x%08x [%d]", gotype->name, gotype->value, gotype->size);
                 for (i = 0; i < gotype->size; i++) {
                         if (!(i%8)) print("\n\t%04x ", i);
                         print("%02x ", gotype->p[i]);
                 }
                 print("\n");
                 for (i = 0; i < gotype->nr; i++) {
                         print("\t0x%02x[%x] %d %s[%llx]\n",
                               gotype->r[i].off,
                               gotype->r[i].siz,
@@ skipping 83 matching lines @@
                         newrefattr(fld, DW_AT_type, defptrto(defgotype(s)));
                 }
                 die = defptrto(die);
                 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("type.runtime.eface", 0);
+                        s = lookup_or_diag("type.runtime.eface");
                 else
-                        s = lookup("type.runtime.iface", 0);
+                        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;
@@ skipping 96 matching lines @@
                 a->data = (char*) dwtype;
         else
                 newrefattr(child, DW_AT_type, dwtype);
 }
 
 static void
 synthesizestringtypes(DWDie* die)
 {
         DWDie *prototype;
 
-        prototype = defgotype(lookup("type.runtime.string_", 0));
+        prototype = defgotype(lookup_or_diag("type.string"));
         if (prototype == nil)
-                return;
+                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("type.runtime.slice",0));
+        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));
         }
@@ skipping 18 matching lines @@
 // 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, *keytype, *valtype, *fld;
+                *dwh, *dwhs, *dwhe, *dwhash, *keytype, *valtype, *fld;
         int hashsize, keysize, valsize, datsize, valsize_in_hash, datavo;
         DWAttr *a;
 
-        hash            = defgotype(lookup("type.runtime.hash",0));
-        hash_subtable   = defgotype(lookup("type.runtime.hash_subtable",0));
-        hash_entry      = defgotype(lookup("type.runtime.hash_entry",0));
+        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;
 
-        dwh = (DWDie*)getattr(find_or_diag(hash_entry, "hash"), DW_AT_type)->data;
-        if (dwh == nil)
+        dwhash = (DWDie*)getattr(find_or_diag(hash_entry, "hash"), DW_AT_type)->data;
+        if (dwhash == nil)
                 return;
 
-        hashsize = getattr(dwh, DW_AT_byte_size)->value;
+        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
@@ skipping 11 matching lines @@
                 datsize = datavo + valsize_in_hash;
                 if (datsize < PtrSize)
                         datsize = PtrSize;
                 datsize = rnd(datsize, PtrSize);
 
                 // Construct struct hash_entry<K,V>
                 dwhe = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
                         mkinternaltypename("hash_entry",
                                 getattr(keytype, DW_AT_name)->data,
                                 getattr(valtype, DW_AT_name)->data));
-                copychildren(dwhe, hash_entry);
-                substitutetype(dwhe, "key", keytype);
+
+                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);
-                substitutetype(dwhe, "val", valtype);
-                fld = find_or_diag(dwhe, "val");
-                delattr(fld, DW_AT_data_member_location);
+                newrefattr(fld, DW_AT_type, valtype);
                 newmemberoffsetattr(fld, hashsize + datavo);
                 newattr(dwhe, DW_AT_byte_size, DW_CLS_CONSTANT, hashsize + datsize, NULL);
 
                 // Construct hash_subtable<hash_entry<K,V>>
                 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, "end", defptrto(dwhe));
@@ skipping 16 matching lines @@
 }
 
 static void
 synthesizechantypes(DWDie *die)
 {
         DWDie *sudog, *waitq, *link, *hchan,
                 *dws, *dww, *dwl, *dwh, *elemtype;
         DWAttr *a;
         int elemsize, linksize, sudogsize;
 
-        sudog = defgotype(lookup("type.runtime.sudoG",0));
-        waitq = defgotype(lookup("type.runtime.waitQ",0));
-        link  = defgotype(lookup("type.runtime.link",0));
-        hchan = defgotype(lookup("type.runtime.hChan",0));
+        sudog = defgotype(lookup_or_diag("type.runtime.sudog"));
+        waitq = defgotype(lookup_or_diag("type.runtime.waitq"));
+        link  = defgotype(lookup_or_diag("type.runtime.link"));
+        hchan = defgotype(lookup_or_diag("type.runtime.hchan"));
         if (sudog == nil || waitq == nil || link == nil || hchan == nil)
                 return;
 
         sudogsize = getattr(sudog, DW_AT_byte_size)->value;
         linksize = getattr(link, 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;
@@ skipping 925 matching lines @@
         // Some types that must exist to define other ones.
         newdie(&dwtypes, DW_ABRV_NULLTYPE, "<unspecified>");
         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("type.runtime.commonType",0));
-        defgotype(lookup("type.runtime.InterfaceType",0));
-        defgotype(lookup("type.runtime.itab",0));
+        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);
 
@@ skipping 240 matching lines @@
         newPEDWARFSection(".debug_info", infosize);
         if (pubnamessize > 0)
                 newPEDWARFSection(".debug_pubnames", pubnamessize);
         if (pubtypessize > 0)
                 newPEDWARFSection(".debug_pubtypes", pubtypessize);
         if (arangessize > 0)
                 newPEDWARFSection(".debug_aranges", arangessize);
         if (gdbscriptsize > 0)
                 newPEDWARFSection(".debug_gdb_scripts", gdbscriptsize);
 }