| blob | e38972913be2df18324e6704b85e0807d3fbb0c1 |
1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // Annotate Ref in Prog with C types by parsing gcc debug output.
6 // Conversion of debug output to Go types.
8 package main
11 "bytes"
12 "debug/dwarf"
13 "debug/elf"
14 "debug/macho"
15 "debug/pe"
16 "encoding/binary"
17 "errors"
18 "flag"
19 "fmt"
20 "go/ast"
21 "go/parser"
22 "go/token"
23 "internal/xcoff"
24 "math"
25 "os"
26 "strconv"
27 "strings"
28 "unicode"
29 "unicode/utf8"
30 )
45 }
47 // cname returns the C name to use for C.s.
48 // The expansions are listed in nameToC and also
49 // struct_foo becomes "struct foo", and similarly for
50 // union and enum.
53 return t
54 }
58 }
61 }
64 }
67 }
68 return s
69 }
71 // DiscardCgoDirectives processes the import C preamble, and discards
72 // all #cgo CFLAGS and LDFLAGS directives, so they don't make their
73 // way into _cgo_export.h.
83 }
84 }
86 }
88 // addToFlag appends args to flag. All flags are later written out onto the
89 // _cgo_flags file for the build system to use.
92 // We'll also need these when preprocessing for dwarf information.
93 // However, discard any -g options: we need to be able
94 // to parse the debug info, so stick to what we expect.
98 }
99 }
100 }
104 // The go tool will pass us a -I option pointing to objdir;
105 // we don't need to record that for later, as the objdir
106 // will disappear anyhow.
108 // Discard argument in "-I objdir" case.
111 // This is -Iobjdir. Don't save this argument.
113 // This is -I objdir. Don't save this argument
114 // or the next one.
118 }
119 }
120 }
122 // splitQuoted splits the string s around each instance of one or more consecutive
123 // white space characters while taking into account quotes and escaping, and
124 // returns an array of substrings of s or an empty list if s contains only white space.
125 // Single quotes and double quotes are recognized to prevent splitting within the
126 // quoted region, and are removed from the resulting substrings. If a quote in s
127 // isn't closed err will be set and r will have the unclosed argument as the
128 // last element. The backslash is used for escaping.
129 //
130 // For example, the following string:
131 //
132 // `a b:"c d" 'e''f' "g\""`
133 //
134 // Would be parsed as:
135 //
136 // []string{"a", "b:c d", "ef", `g"`}
137 //
151 continue
155 continue
156 }
159 quote = r
160 continue
166 }
167 continue
168 }
170 i++
171 }
174 }
179 }
181 }
183 // Translate rewrites f.AST, the original Go input, to remove
184 // references to the imported package C, replacing them with
185 // references to the equivalent Go types, functions, and variables.
188 // Convert C.ulong to C.unsigned long, etc.
190 }
192 var conv typeConv
201 // Also ask about any typedefs we've seen so far.
206 }
209 }
213 }
215 // In godefs mode we're OK with the typedefs, which
216 // will presumably also be defined in the file, we
217 // don't want to resolve them to their base types.
219 break
220 }
221 }
224 // Add `import _cgo_unsafe "unsafe"` after the package statement.
226 }
228 }
230 // loadDefines coerces gcc into spitting out the #defines in use
231 // in the file f and saves relevant renamings in f.Name[name].Define.
240 continue
241 }
250 continue
257 }
261 }
266 }
268 }
269 }
270 }
272 // guessKinds tricks gcc into revealing the kind of each
273 // name xxx for the references C.xxx in the Go input.
274 // The kind is either a constant, type, or variable.
276 // Determine kinds for names we already know about,
277 // like #defines or 'struct foo', before bothering with gcc.
282 // If we've already found this name as a #define
283 // and we can translate it as a constant value, do so.
287 // Turn decimal into hex, just for consistency
288 // with enum-derived constants. Otherwise
289 // in the cgo -godefs output half the constants
290 // are in hex and half are in whatever the #define used.
296 }
301 }
302 }
305 continue
306 }
307 }
309 // If this is a struct, union, or enum type name, no need to guess the kind.
310 if strings.HasPrefix(n.C, "struct ") || strings.HasPrefix(n.C, "union ") || strings.HasPrefix(n.C, "enum ") {
313 continue
314 }
317 // For FooRef, find out if FooGetTypeID exists.
322 }
324 // Otherwise, we'll need to find out from gcc.
326 }
328 // Bypass gcc if there's nothing left to find out.
330 return needType
331 }
333 // Coerce gcc into telling us whether each name is a type, a value, or undeclared.
334 // For names, find out whether they are integer constants.
335 // We used to look at specific warning or error messages here, but that tied the
336 // behavior too closely to specific versions of the compilers.
337 // Instead, arrange that we can infer what we need from only the presence or absence
338 // of an error on a specific line.
339 //
340 // For each name, we generate these lines, where xxx is the index in toSniff plus one.
341 //
342 // #line xxx "not-declared"
343 // void __cgo_f_xxx_1(void) { __typeof__(name) *__cgo_undefined__1; }
344 // #line xxx "not-type"
345 // void __cgo_f_xxx_2(void) { name *__cgo_undefined__2; }
346 // #line xxx "not-int-const"
347 // void __cgo_f_xxx_3(void) { enum { __cgo_undefined__3 = (name)*1 }; }
348 // #line xxx "not-num-const"
349 // void __cgo_f_xxx_4(void) { static const double __cgo_undefined__4 = (name); }
350 // #line xxx "not-str-lit"
351 // void __cgo_f_xxx_5(void) { static const char __cgo_undefined__5[] = (name); }
352 //
353 // If we see an error at not-declared:xxx, the corresponding name is not declared.
354 // If we see an error at not-type:xxx, the corresponding name is a type.
355 // If we see an error at not-int-const:xxx, the corresponding name is not an integer constant.
356 // If we see an error at not-num-const:xxx, the corresponding name is not a number constant.
357 // If we see an error at not-str-lit:xxx, the corresponding name is not a string literal.
358 //
359 // The specific input forms are chosen so that they are valid C syntax regardless of
360 // whether name denotes a type or an expression.
382 )
383 }
390 }
396 notIntConst
397 notNumConst
398 notStrLiteral
399 notDeclared
400 )
403 // Ignore warnings and random comments, with one
404 // exception: newer GCC versions will sometimes emit
405 // an error on a macro #define with a note referring
406 // to where the expansion occurs. We care about where
407 // the expansion occurs, so in that case treat the note
408 // as an error.
412 continue
413 }
417 continue
418 }
421 continue
422 }
427 i--
431 }
432 continue
433 }
437 // Strictly speaking, there is no guarantee that seeing the error at completed:1
438 // (at the end of the file) means we've seen all the errors from earlier in the file,
439 // but usually it does. Certainly if we don't see the completed:1 error, we did
440 // not get all the errors we expected.
456 }
457 continue
458 }
461 }
464 fatalf("%s did not produce error at completed:1\non input:\n%s\nfull error output:\n%s", p.gccBaseCmd()[0], b.Bytes(), stderr)
465 }
471 // Ignore optional undeclared identifiers.
472 // Don't report an error, and skip adding n to the needType array.
473 continue
474 }
486 }
488 }
490 // Check if compiling the preamble by itself causes any errors,
491 // because the messages we've printed out so far aren't helpful
492 // to users debugging preamble mistakes. See issue 8442.
496 }
499 }
501 return needType
502 }
504 // loadDWARF parses the DWARF debug information generated
505 // by gcc to learn the details of the constants, variables, and types
506 // being referred to as C.xxx.
508 // Extract the types from the DWARF section of an object
509 // from a well-formed C program. Gcc only generates DWARF info
510 // for symbols in the object file, so it is not enough to print the
511 // preamble and hope the symbols we care about will be there.
512 // Instead, emit
513 // __typeof__(names[i]) *__cgo__i;
514 // for each entry in names and then dereference the type we
515 // learn for __cgo__i.
524 }
525 }
527 // We create a data block initialized with the values,
528 // so we can read them out of the object file.
535 }
536 }
537 // for the last entry, we cannot use 0, otherwise
538 // in case all __cgodebug_data is zero initialized,
539 // LLVM-based gcc will place the it in the __DATA.__common
540 // zero-filled section (our debug/macho doesn't support
541 // this)
545 // do the same work for floats.
552 }
553 }
557 // do the same work for strings.
562 }
563 }
567 // Scan DWARF info for top-level TagVariable entries with AttrName __cgo__i.
574 }
576 break
577 }
584 // Since we are reading all the DWARF,
585 // assume we will see the variable elsewhere.
586 break
587 }
589 }
591 break
592 }
596 }
600 }
604 }
607 }
610 }
611 }
613 // Record types and typedef information.
617 }
618 }
621 continue
622 }
637 }
638 }
641 break
642 }
645 // This has an integer type so it's
646 // not really a floating point
647 // constant. This can happen when the
648 // C compiler complains about using
649 // the value as an integer constant,
650 // but not as a general constant.
651 // Treat this as a variable of the
652 // appropriate type, not a constant,
653 // to get C-style type handling,
654 // avoiding the problem that C permits
655 // uint64(-1) but Go does not.
656 // See issue 26066.
660 }
664 }
665 }
666 }
668 }
669 }
671 // recordTypedefs remembers in p.typedefs all the typedefs used in dtypes and its children.
674 }
676 func (p *Package) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited map[dwarf.Type]bool) {
678 return
679 }
681 return
682 }
687 // Don't look inside builtin types. There be dragons.
688 return
689 }
694 }
705 }
709 }
710 }
711 }
713 // prepareNames finalizes the Kind field of not-type names and sets
714 // the mangled name of all names.
726 },
727 }
728 }
729 }
731 }
732 }
734 // mangleName does name mangling to translate names
735 // from the original Go source files to the names
736 // used in the final Go files generated by cgo.
738 // When using gccgo variables have to be
739 // exported so that they become global symbols
740 // that the C code can refer to.
744 }
746 }
755 }
756 }
757 }
759 }
761 // rewriteCalls rewrites all calls that pass pointers to check that
762 // they follow the rules for passing pointers between Go and C.
763 // This reports whether the package needs to import unsafe as _cgo_unsafe.
766 // Walk backward so that in C.f1(C.f2()) we rewrite C.f2 first.
769 continue
770 }
778 }
779 }
780 }
781 return needsUnsafe
782 }
784 // rewriteCall rewrites one call to add pointer checks.
785 // If any pointer checks are required, we rewrite the call into a
786 // function literal that calls _cgoCheckPointer for each pointer
787 // argument and then calls the original function.
788 // This returns the rewritten call and whether the package needs to
789 // import unsafe as _cgo_unsafe.
790 // If it returns the empty string, the call did not need to be rewritten.
792 // This is a call to C.xxx; set goname to "xxx".
793 // It may have already been mangled by rewriteName.
801 }
804 }
807 // Probably a type conversion.
809 }
814 // Avoid a crash if the number of arguments doesn't match
815 // the number of parameters.
816 // This will be caught when the generated file is compiled.
819 }
825 break
826 }
827 }
830 }
832 // We need to rewrite this call.
833 //
834 // Rewrite C.f(p) to
835 // func() {
836 // _cgo0 := p
837 // _cgoCheckPointer(_cgo0, nil)
838 // C.f(_cgo0)
839 // }()
840 // Using a function literal like this lets us evaluate the
841 // function arguments only once while doing pointer checks.
842 // This is particularly useful when passing additional arguments
843 // to _cgoCheckPointer, as done in checkIndex and checkAddr.
844 //
845 // When the function argument is a conversion to unsafe.Pointer,
846 // we unwrap the conversion before checking the pointer,
847 // and then wrap again when calling C.f. This lets us check
848 // the real type of the pointer in some cases. See issue #25941.
849 //
850 // When the call to C.f is deferred, we use an additional function
851 // literal to evaluate the arguments at the right time.
852 // defer func() func() {
853 // _cgo0 := p
854 // return func() {
855 // _cgoCheckPointer(_cgo0, nil)
856 // C.f(_cgo0)
857 // }
858 // }()()
859 // This works because the defer statement evaluates the first
860 // function literal in order to get the function to call.
866 }
872 // Check whether this call expects two results.
875 continue
876 }
881 }
882 break
883 }
885 // Add the result type, if any.
890 }
893 }
895 // Add the second result type, if any.
898 // An explicit void result looks odd but it
899 // seems to be how cgo has worked historically.
901 }
903 }
904 }
908 // Define _cgoN for each argument value.
909 // Write _cgoCheckPointer calls to sbCheck.
916 }
918 // Use "var x T = ..." syntax to explicitly convert untyped
919 // constants to the parameter type, to avoid a type mismatch.
925 }
928 continue
929 }
931 // Check for &a[i].
933 continue
934 }
936 // Check for &x.
938 continue
939 }
943 }
947 }
949 // Write out the calls to _cgoCheckPointer.
954 }
959 }
966 }
968 }
972 }
976 }
980 }
982 // needsPointerCheck reports whether the type t needs a pointer check.
983 // This is true if t is a pointer and if the value to which it points
984 // might contain a pointer.
986 // An untyped nil does not need a pointer check, and when
987 // _cgoCheckPointer returns the untyped nil the type assertion we
988 // are going to insert will fail. Easier to just skip nil arguments.
989 // TODO: Note that this fails if nil is shadowed.
992 }
995 }
997 // hasPointer is used by needsPointerCheck. If top is true it returns
998 // whether t is or contains a pointer that might point to a pointer.
999 // If top is false it reports whether t is or contains a pointer.
1000 // f may be nil.
1007 }
1009 }
1015 }
1016 }
1021 }
1022 // Check whether this is a pointer to a C union (or class)
1023 // type that contains a pointer.
1026 }
1031 // TODO: Handle types defined within function.
1035 continue
1036 }
1040 continue
1041 }
1044 }
1045 }
1046 }
1049 }
1052 }
1055 }
1058 }
1059 // We can't figure out the type. Conservative
1060 // approach is to assume it has a pointer.
1064 // Type defined in a different package.
1065 // Conservative approach is to assume it has a
1066 // pointer.
1068 }
1070 // Conservative approach: assume pointer.
1072 }
1076 }
1077 // We can't figure out the type. Conservative
1078 // approach is to assume it has a pointer.
1083 }
1084 }
1086 // mangle replaces references to C names in arg with the mangled names,
1087 // rewriting calls when it finds them.
1088 // It removes the corresponding references in f.Ref and f.Calls, so that we
1089 // don't try to do the replacement again in rewriteRef or rewriteCall.
1095 return
1096 }
1100 return
1101 }
1107 break
1108 }
1109 }
1111 return
1112 }
1116 return
1117 }
1123 // Smuggle the rewritten call through an ident.
1127 }
1129 }
1130 }
1131 }
1132 })
1134 }
1136 // checkIndex checks whether arg has the form &a[i], possibly inside
1137 // type conversions. If so, then in the general case it writes
1138 // _cgoIndexNN := a
1139 // _cgoNN := &cgoIndexNN[i] // with type conversions, if any
1140 // to sb, and writes
1141 // _cgoCheckPointer(_cgoNN, _cgoIndexNN)
1142 // to sbCheck, and returns true. If a is a simple variable or field reference,
1143 // it writes
1144 // _cgoIndexNN := &a
1145 // and dereferences the uses of _cgoIndexNN. Taking the address avoids
1146 // making a copy of an array.
1147 //
1148 // This tells _cgoCheckPointer to check the complete contents of the
1149 // slice or array being indexed, but no other part of the memory allocation.
1151 // Strip type conversions.
1152 x := arg
1156 break
1157 }
1159 }
1163 }
1167 }
1174 }
1181 }
1188 }
1190 // checkAddr checks whether arg has the form &x, possibly inside type
1191 // conversions. If so, it writes
1192 // _cgoBaseNN := &x
1193 // _cgoNN := _cgoBaseNN // with type conversions, if any
1194 // to sb, and writes
1195 // _cgoCheckPointer(_cgoBaseNN, true)
1196 // to sbCheck, and returns true. This tells _cgoCheckPointer to check
1197 // just the contents of the pointer being passed, not any other part
1198 // of the memory allocation. This is run after checkIndex, which looks
1199 // for the special case of &a[i], which requires different checks.
1201 // Strip type conversions.
1202 px := &arg
1206 break
1207 }
1209 }
1212 }
1216 origX := *px
1221 // Use "0 == 0" to do the right thing in the unlikely event
1222 // that "true" is shadowed.
1226 }
1228 // isType reports whether the expression is definitely a type.
1229 // This is conservative--it returns false for an unknown identifier.
1236 }
1239 }
1242 }
1245 // TODO: This ignores shadowing.
1256 }
1259 }
1268 }
1270 }
1272 // isVariable reports whether x is a variable, possibly with field references.
1281 }
1283 }
1285 // rewriteUnsafe returns a version of t with references to unsafe.Pointer
1286 // rewritten to use _cgo_unsafe.Pointer instead.
1290 // We don't see a SelectorExpr for unsafe.Pointer;
1291 // this is created by code in this file.
1294 }
1298 r := *t
1301 }
1311 fn := *f
1315 }
1316 }
1318 r := *t
1321 }
1325 r := *t
1328 }
1329 }
1330 return t
1331 }
1333 // rewriteRef rewrites all the C.xxx references in f.AST to refer to the
1334 // Go equivalents, now that we have figured out the meaning of all
1335 // the xxx. In *godefs mode, rewriteRef replaces the names
1336 // with full definitions instead of mangled names.
1338 // Keep a list of all the functions, to remove the ones
1339 // only used as expressions and avoid generating bridge
1340 // code for them.
1346 }
1347 }
1349 // Now that we have all the name types filled in,
1350 // scan through the Refs to identify the ones that
1351 // are trying to do a ,err call. Also check that
1352 // functions are only used in calls.
1356 }
1362 }
1363 }
1368 // Substitute definition for mangled type name.
1372 }
1375 }
1376 }
1377 }
1379 // Copy position information from old expr into new expr,
1380 // in case expression being replaced is first on line.
1381 // See golang.org/issue/6563.
1385 }
1387 // Change AST, because some later processing depends on it,
1388 // and also because -godefs mode still prints the AST.
1392 // Record source-level edit for cgo output.
1394 // Prepend a space in case the earlier code ends
1395 // with '/', which would give us a "//" comment.
1398 // Subtract 1 from the column if we are going to
1399 // append a close parenthesis. That will set the
1400 // correct column for the following characters.
1404 }
1407 }
1410 }
1412 }
1413 }
1415 // Remove functions only used as expressions, so their respective
1416 // bridge functions are not generated.
1420 }
1421 }
1422 }
1424 // rewriteName returns the expression used to rewrite a reference.
1433 error_(r.Pos(), "invalid conversion to C.%s: undefined C type '%s'", fixGo(r.Name.Go), r.Name.C)
1434 break
1435 }
1437 break
1438 }
1440 break
1441 }
1445 break
1446 }
1447 // Invent new Name for the two-result function.
1455 }
1458 break
1459 }
1465 }
1467 // Function is being used in an expression, to e.g. pass around a C function pointer.
1468 // Create a new Name for this Ref which causes the variable to be declared in Go land.
1476 Type: &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*"), Go: ast.NewIdent("unsafe.Pointer")},
1477 }
1480 }
1482 // Rewrite into call to _Cgo_ptr to prevent assignments. The _Cgo_ptr
1483 // function is defined in out.go and simply returns its argument. See
1484 // issue 7757.
1488 }
1490 // Okay - might be new(T)
1493 break
1494 }
1500 }
1506 }
1511 // Use of C.enum_x, C.struct_x or C.union_x without C definition.
1512 // GCC won't raise an error when using pointers to such unknown types.
1516 }
1520 }
1521 }
1522 return expr
1523 }
1525 // gofmtPos returns the gofmt-formatted string for an AST node,
1526 // with a comment setting the position before the node.
1531 return s
1532 }
1534 }
1536 // gccBaseCmd returns the start of the compiler command line.
1537 // It uses $CC if set, or else $GCC, or else the compiler recorded
1538 // during the initial build as defaultCC.
1539 // defaultCC is defined in zdefaultcc.go, written by cmd/dist.
1541 // Use $CC if set, since that's what the build uses.
1543 return ret
1544 }
1545 // Try $GCC if set, since that's what we used to use.
1547 return ret
1548 }
1550 }
1552 // gccMachine returns the gcc -m flag to use, either "-m32", "-m64" or "-marm".
1572 }
1573 }
1575 }
1579 }
1581 // gccCmd returns the gcc command line to use for compiling
1582 // the input.
1591 )
1595 // Apple clang version 1.7 (tags/Apple/clang-77) (based on LLVM 2.9svn)
1596 // doesn't have -Wno-unneeded-internal-declaration, so we need yet another
1597 // flag to disable the warning. Yes, really good diagnostics, clang.
1602 // Clang embeds prototypes for some builtin functions,
1603 // like malloc and calloc, but all size_t parameters are
1604 // incorrectly typed unsigned long. We work around that
1605 // by disabling the builtin functions (this is safe as
1606 // it won't affect the actual compilation of the C code).
1607 // See: https://golang.org/issue/6506.
1609 )
1610 }
1617 }
1619 return c
1620 }
1622 // gccDebug runs gcc -gdwarf-2 over the C program stdin and
1623 // returns the corresponding DWARF data and, if present, debug data block.
1624 func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int64, floats []float64, strs []string) {
1628 // Some systems use leading _ to denote non-assembly symbols.
1630 }
1632 // Some systems use leading _ to denote non-assembly symbols.
1634 }
1636 // Some systems use leading _ to denote non-assembly symbols.
1639 }
1642 return n
1643 }
1644 }
1646 }
1648 // Some systems use leading _ to denote non-assembly symbols.
1651 }
1654 return n
1655 }
1656 }
1658 }
1670 }
1672 }
1673 }
1680 }
1687 // Found it. Now find data section.
1696 }
1697 }
1698 }
1699 }
1701 // Found it. Now find data section.
1710 }
1711 }
1712 }
1713 }
1716 // Found it. Now find data section.
1723 }
1724 }
1725 }
1726 break
1727 }
1729 // Found it. Now find data section.
1738 }
1740 }
1741 }
1742 }
1743 break
1744 }
1745 }
1746 }
1749 }
1751 }
1758 }
1766 // Found it. Now find data section.
1775 }
1776 }
1777 }
1778 }
1780 // Found it. Now find data section.
1789 }
1790 }
1791 }
1792 }
1795 // Found it. Now find data section.
1802 }
1803 }
1804 }
1805 break
1806 }
1808 // Found it. Now find data section.
1817 }
1819 }
1820 }
1821 }
1822 break
1823 }
1824 }
1825 }
1828 }
1830 }
1837 }
1850 }
1851 }
1852 }
1853 }
1863 }
1864 }
1865 }
1866 }
1875 }
1876 }
1877 }
1878 break
1879 }
1889 }
1891 }
1892 }
1893 }
1894 break
1895 }
1896 }
1897 }
1902 }
1909 }
1922 }
1923 }
1924 }
1925 }
1935 }
1936 }
1937 }
1938 }
1947 }
1948 }
1949 }
1950 break
1951 }
1961 }
1963 }
1964 }
1965 }
1966 break
1967 }
1968 }
1969 }
1973 }
1976 }
1978 // gccDefines runs gcc -E -dM -xc - over the C program stdin
1979 // and returns the corresponding standard output, which is the
1980 // #defines that gcc encountered while processing the input
1981 // and its included files.
1986 return stdout
1987 }
1989 // gccErrors runs gcc over the C program stdin and returns
1990 // the errors that gcc prints. That is, this function expects
1991 // gcc to fail.
1993 // TODO(rsc): require failure
1996 // Optimization options can confuse the error messages; remove them.
2001 }
2002 }
2004 // Force -O0 optimization but keep the trailing "-" at the end.
2013 }
2018 }
2020 }
2022 // runGcc runs the gcc command line args with stdin on standard input.
2023 // If the command exits with a non-zero exit status, runGcc prints
2024 // details about what was run and exits.
2025 // Otherwise runGcc returns the data written to standard output and standard error.
2026 // Note that for some of the uses we expect useful data back
2027 // on standard error, but for those uses gcc must still exit 0.
2033 }
2038 }
2042 }
2044 }
2046 // A typeConv is a translator from dwarf types to Go types
2047 // with equivalent memory layout.
2049 // Cache of already-translated or in-progress types.
2052 // Map from types to incomplete pointers to those types.
2054 // Keys of ptrs in insertion order (deterministic worklist)
2055 // ptrKeys contains exactly the keys in ptrs.
2058 // Type names X for which there exists an XGetTypeID function with type func() CFTypeID.
2061 // Predeclared types.
2068 void ast.Expr
2073 ptrSize int64
2074 intSize int64
2075 }
2081 // unionWithPointer is true for a Go type that represents a C union (or class)
2082 // that may contain a pointer. This is used for cgo pointer checking.
2085 // anonymousStructTag provides a consistent tag for an anonymous struct.
2086 // The same dwarf.StructType pointer will always get the same tag.
2114 // Normally cgo translates void* to unsafe.Pointer,
2115 // but for historical reasons -godefs uses *byte instead.
2120 }
2121 }
2123 // base strips away qualifiers and typedefs to get the underlying type
2128 continue
2129 }
2132 continue
2133 }
2134 break
2135 }
2136 return dt
2137 }
2139 // unqual strips away qualifiers from a DWARF type.
2140 // In general we don't care about top-level qualifiers.
2146 break
2147 }
2148 }
2149 return dt
2150 }
2152 // Map from dwarf text names to aliases we use in package "C".
2164 }
2168 // String returns the current type representation. Format arguments
2169 // are assembled within this method so that any changes in mutable
2170 // values are taken into account.
2174 }
2177 }
2179 }
2181 // Empty reports whether the result of String would be "".
2184 }
2186 // Set modifies the type representation.
2187 // If fargs are provided, repr is used as a format for fmt.Sprintf.
2188 // Otherwise, repr is used unprocessed as the type representation.
2192 }
2194 // FinishType completes any outstanding type mapping work.
2195 // In particular, it resolves incomplete pointer types.
2197 // Completing one pointer type might produce more to complete.
2198 // Keep looping until they're all done.
2206 // Note Type might invalidate c.ptrs[dtypeKey].
2211 }
2212 }
2213 }
2215 // Type returns a *Type with the same memory layout as
2216 // dtype when used as the type of a variable or a struct field.
2219 }
2221 // loadType recursively loads the requested dtype and its dependency graph.
2223 // Always recompute bad pointer typedefs, as the set of such
2224 // typedefs changes as we see more types.
2228 }
2230 // The cache key should be relative to its parent.
2231 // See issue https://golang.org/issue/31891
2238 }
2239 return t
2240 }
2241 }
2256 }
2262 // Cannot represent bit-sized elements in Go.
2264 break
2265 }
2268 // Indicates flexible array member, which Go doesn't support.
2269 // Translate to zero-length array instead.
2271 }
2277 }
2278 // Recalculate t.Size now that we know sub.Size.
2289 }
2296 }
2303 signed = signedDelta
2304 }
2305 }
2325 }
2335 }
2338 }
2348 }
2351 }
2354 // No attempt at translation: would enable calls
2355 // directly between worlds, but we need to moderate those.
2362 }
2378 }
2379 }
2382 }
2385 // Clang doesn't emit DW_AT_byte_size for pointer types.
2388 }
2401 break
2402 }
2403 }
2404 break
2405 }
2407 // Placeholder initialization; completed in FinishType.
2413 }
2423 }
2427 return t
2430 // Convert to Go struct, being careful about alignment.
2431 // Have to give it a name to simulate C "struct foo" references.
2434 break
2435 }
2440 tagGen++
2442 }
2445 }
2450 // Size calculation in c.Struct/c.Opaque will die with size=-1 (unknown),
2451 // so execute the basic things that the struct case would do
2452 // other than try to determine a Go representation.
2453 tt := *t
2457 break
2458 }
2464 }
2467 }
2474 }
2476 tt := *t
2479 }
2482 }
2485 // Record typedef for printing.
2487 // Special C name for Go string type.
2488 // Knows string layout used by compilers: pointer plus length,
2489 // which rounds up to 2 pointers after alignment.
2493 break
2494 }
2496 // Special C name for Go []byte type.
2497 // Knows slice layout used by compilers: pointer, length, cap.
2501 break
2502 }
2507 // only load type recursively for typedefs of anonymous
2508 // structs, see issues 37479 and 37621.
2509 akey = key
2510 }
2513 // Treat this typedef as a uintptr.
2514 s := *sub
2517 sub = &s
2518 // Make sure we update any previously computed type.
2522 }
2523 }
2528 }
2533 tt := *t
2537 }
2539 // If sub.Go.Name is "_Ctype_struct_foo" or "_Ctype_union_foo" or "_Ctype_class_foo",
2540 // use that as the Go form for this typedef too, so that the typedef will be interchangeable
2541 // with the base type.
2542 // In -godefs mode, do this for all typedefs.
2547 // Use the typedef name for C code.
2549 }
2551 // If we've seen this typedef before, and it
2552 // was an anonymous struct/union/class before
2553 // too, use the old definition.
2554 // TODO: it would be safer to only do this if
2555 // we verify that the types are the same.
2558 }
2559 }
2564 }
2571 }
2587 }
2588 }
2591 }
2597 }
2600 case *dwarf.AddrType, *dwarf.BoolType, *dwarf.CharType, *dwarf.ComplexType, *dwarf.IntType, *dwarf.FloatType, *dwarf.UcharType, *dwarf.UintType:
2604 s = ss
2605 }
2608 tt := *t
2612 }
2613 }
2614 }
2617 // Unsized types are [0]byte, unless they're typedefs of other types
2618 // or structs with tags.
2619 // if so, use the name we've already defined.
2623 // ok
2626 break
2627 }
2631 }
2634 }
2635 }
2639 }
2641 return t
2642 }
2644 // isStructUnionClass reports whether the type described by the Go syntax x
2645 // is a struct, union, or class with a tag.
2650 }
2655 }
2657 // FuncArg returns a Go type with the same memory layout as
2658 // dtype when used as the type of a C function argument.
2663 // Arrays are passed implicitly as pointers in C.
2664 // In Go, we must be explicit.
2672 }
2674 // C has much more relaxed rules than Go for
2675 // implicit type conversions. When the parameter
2676 // is type T defined as *X, simulate a little of the
2677 // laxness of C by making the argument *X instead of T.
2679 // Unless the typedef happens to point to void* since
2680 // Go has special rules around using unsafe.Pointer.
2682 break
2683 }
2684 // ...or the typedef is one in which we expect bad pointers.
2685 // It will be a uintptr instead of *X.
2687 break
2688 }
2693 }
2695 // For a struct/union/class, remember the C spelling,
2696 // in case it has __attribute__((unavailable)).
2697 // See issue 2888.
2700 }
2701 }
2702 }
2703 return t
2704 }
2706 // FuncType returns the Go type analogous to dtype.
2707 // There is no guarantee about matching memory layout.
2712 // gcc's DWARF generator outputs a single DotDotDotType parameter for
2713 // function pointers that specify no parameters (e.g. void
2714 // (*__cgo_0)()). Treat this special case as void. This case is
2715 // invalid according to ISO C anyway (i.e. void (*__cgo_1)(...) is not
2716 // legal).
2719 break
2720 }
2723 }
2731 }
2738 },
2739 }
2740 }
2742 // Identifier
2745 }
2747 // Opaque type of n bytes.
2752 }
2753 }
2755 // Expr for integer n.
2760 }
2761 }
2763 // Add padding of given size to fld.
2771 }
2773 // Struct conversion: return Go and (gc) C syntax for type.
2774 func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.StructType, csyntax string, align int64) {
2775 // Minimum alignment for a struct is 1 byte.
2784 // Rename struct fields that happen to be named Go keywords into
2785 // _{keyword}. Create a map from C ident -> Go ident. The Go ident will
2786 // be mangled. Any existing identifier that already has the same name on
2787 // the C-side will cause the Go-mangled version to be prefixed with _.
2788 // (e.g. in a struct with fields '_type' and 'type', the latter would be
2789 // rendered as '__type' in Go).
2795 }
2800 // Avoid keyword
2803 // Also avoid existing fields
2806 }
2810 }
2811 }
2812 }
2819 // In godefs mode, if this field is a C11
2820 // anonymous union then treat the first field in the
2821 // union as the field in the struct. This handles
2822 // cases like the glibc <sys/resource.h> file; see
2823 // issue 6677.
2825 if st, ok := f.Type.(*dwarf.StructType); ok && name == "" && st.Kind == "union" && len(st.Field) > 0 && !used[st.Field[0].Name] {
2829 }
2830 }
2832 // TODO: Handle fields that are anonymous structs by
2833 // promoting the fields of the inner struct.
2843 continue
2844 }
2851 }
2853 talign = size
2854 }
2857 // Drop misaligned fields, the same way we drop integer bit fields.
2858 // The goal is to make available what can be made available.
2859 // Otherwise one bad and unneeded field in an otherwise okay struct
2860 // makes the whole program not compile. Much of the time these
2861 // structs are in system headers that cannot be corrected.
2862 continue
2863 }
2865 // Round off up to talign, assumed to be a power of 2.
2871 }
2873 // Drop a packed field that we can't represent.
2874 continue
2875 }
2881 anon++
2883 }
2887 off += size
2893 align = talign
2894 }
2895 }
2899 }
2901 // If the last field in a non-zero-sized struct is zero-sized
2902 // the compiler is going to pad it by one (see issue 9401).
2903 // We can't permit that, because then the size of the Go
2904 // struct will not be the same as the size of the C struct.
2905 // Our only option in such a case is to remove the field,
2906 // which means that it cannot be referenced from Go.
2911 }
2915 }
2921 }
2923 return
2924 }
2926 // dwarfHasPointer reports whether the DWARF type dt contains a pointer.
2952 }
2953 }
2959 }
2961 }
2962 }
2967 }
2971 }
2973 }
2975 // godefsFields rewrites field names for use in Go or C definitions.
2976 // It strips leading common prefixes (like tv_ in tv_sec, tv_usec)
2977 // converts names to upper case, and rewrites _ into Pad_godefs_n,
2978 // so that all fields are exported.
2986 }
2988 // Use exported name instead.
2990 npad++
2991 }
2993 }
2994 }
2995 }
2997 // fieldPrefix returns the prefix that should be removed from all the
2998 // field names when generating the C or Go code. For generated
2999 // C, we leave the names as is (tv_sec, tv_usec), since that's what
3000 // people are used to seeing in C. For generated Go code, such as
3001 // package syscall's data structures, we drop a common prefix
3002 // (so sec, usec, which will get turned into Sec, Usec for exporting).
3007 // Ignore field names that don't have the prefix we're
3008 // looking for. It is common in C headers to have fields
3009 // named, say, _pad in an otherwise prefixed header.
3010 // If the struct has 3 fields tv_sec, tv_usec, _pad1, then we
3011 // still want to remove the tv_ prefix.
3012 // The check for "orig_" here handles orig_eax in the
3013 // x86 ptrace register sets, which otherwise have all fields
3014 // with reg_ prefixes.
3016 continue
3017 }
3020 continue
3021 }
3026 }
3027 }
3028 }
3029 return prefix
3030 }
3032 // anonymousStructTypedef reports whether dt is a C typedef for an anonymous
3033 // struct.
3037 }
3039 // badPointerTypedef reports whether t is a C typedef that should not be considered a pointer in Go.
3040 // A typedef is bad if C code sometimes stores non-pointers in this type.
3041 // TODO: Currently our best solution is to find these manually and list them as
3042 // they come up. A better solution is desired.
3046 }
3049 }
3052 }
3054 }
3056 // baseBadPointerTypedef reports whether the base of a chain of typedefs is a bad typedef
3057 // as badPointerTypedef reports.
3061 dt = t
3062 continue
3063 }
3064 break
3065 }
3067 }
3070 // The real bad types are CFNumberRef and CFDateRef.
3071 // Sometimes non-pointers are stored in these types.
3072 // CFTypeRef is a supertype of those, so it can have bad pointers in it as well.
3073 // We return true for the other *Ref types just so casting between them is easier.
3074 // We identify the correct set of types as those ending in Ref and for which
3075 // there exists a corresponding GetTypeID function.
3076 // See comment below for details about the bad pointers.
3079 }
3083 }
3087 }
3090 }
3092 // Mutable and immutable variants share a type ID.
3094 }
3096 }
3098 // Comment from Darwin's CFInternal.h
3099 /*
3100 // Tagged pointer support
3101 // Low-bit set means tagged object, next 3 bits (currently)
3102 // define the tagged object class, next 4 bits are for type
3103 // information for the specific tagged object class. Thus,
3104 // the low byte is for type info, and the rest of a pointer
3105 // (32 or 64-bit) is for payload, whatever the tagged class.
3106 //
3107 // Note that the specific integers used to identify the
3108 // specific tagged classes can and will change from release
3109 // to release (that's why this stuff is in CF*Internal*.h),
3110 // as can the definition of type info vs payload above.
3111 //
3112 #if __LP64__
3113 #define CF_IS_TAGGED_OBJ(PTR) ((uintptr_t)(PTR) & 0x1)
3114 #define CF_TAGGED_OBJ_TYPE(PTR) ((uintptr_t)(PTR) & 0xF)
3115 #else
3116 #define CF_IS_TAGGED_OBJ(PTR) 0
3117 #define CF_TAGGED_OBJ_TYPE(PTR) 0
3118 #endif
3120 enum {
3121 kCFTaggedObjectID_Invalid = 0,
3122 kCFTaggedObjectID_Atom = (0 << 1) + 1,
3123 kCFTaggedObjectID_Undefined3 = (1 << 1) + 1,
3124 kCFTaggedObjectID_Undefined2 = (2 << 1) + 1,
3125 kCFTaggedObjectID_Integer = (3 << 1) + 1,
3126 kCFTaggedObjectID_DateTS = (4 << 1) + 1,
3127 kCFTaggedObjectID_ManagedObjectID = (5 << 1) + 1, // Core Data
3128 kCFTaggedObjectID_Date = (6 << 1) + 1,
3129 kCFTaggedObjectID_Undefined7 = (7 << 1) + 1,
3130 };
3131 */
3134 // In Dalvik and ART, the jobject type in the JNI interface of the JVM has the
3135 // property that it is sometimes (always?) a small integer instead of a real pointer.
3136 // Note: although only the android JVMs are bad in this respect, we declare the JNI types
3137 // bad regardless of platform, so the same Go code compiles on both android and non-android.
3139 // Try to make sure we're talking about a JNI type, not just some random user's
3140 // type that happens to use the same name.
3141 // C doesn't have the notion of a package, so it's hard to be certain.
3143 // Walk up to jobject, checking each typedef on the way.
3144 w := dt
3149 }
3150 w = t
3154 }
3155 }
3157 // Check that the typedef is either:
3158 // 1:
3159 // struct _jobject;
3160 // typedef struct _jobject *jobject;
3161 // 2: (in NDK16 in C++)
3162 // class _jobject {};
3163 // typedef _jobject* jobject;
3164 // 3: (in NDK16 in C)
3165 // typedef void* jobject;
3176 }
3180 }
3181 }
3182 }
3183 }
3184 }
3185 }
3187 }
3192 }
3193 // Check that the typedef is "typedef void *EGLDisplay".
3197 }
3198 }
3200 }
3202 // jniTypes maps from JNI types that we want to be uintptrs, to the underlying type to which
3203 // they are mapped. The base "jobject" maps to the empty string.
3220 }