123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935 |
- // Copyright 2009 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.
- package main
- import (
- "bytes"
- "cmd/internal/pkgpath"
- "debug/elf"
- "debug/macho"
- "debug/pe"
- "fmt"
- "go/ast"
- "go/printer"
- "go/token"
- exec "internal/execabs"
- "internal/xcoff"
- "io"
- "os"
- "path/filepath"
- "regexp"
- "sort"
- "strings"
- "unicode"
- )
- var (
- conf = printer.Config{Mode: printer.SourcePos, Tabwidth: 8}
- noSourceConf = printer.Config{Tabwidth: 8}
- )
- // writeDefs creates output files to be compiled by gc and gcc.
- func (p *Package) writeDefs() {
- var fgo2, fc io.Writer
- f := creat(*objDir + "_cgo_gotypes.go")
- defer f.Close()
- fgo2 = f
- if *gccgo {
- f := creat(*objDir + "_cgo_defun.c")
- defer f.Close()
- fc = f
- }
- fm := creat(*objDir + "_cgo_main.c")
- var gccgoInit bytes.Buffer
- fflg := creat(*objDir + "_cgo_flags")
- var flags []string
- for k, v := range p.CgoFlags {
- flags = append(flags, fmt.Sprintf("_CGO_%s=%s", k, strings.Join(v, " ")))
- if k == "LDFLAGS" && !*gccgo {
- for _, arg := range v {
- fmt.Fprintf(fgo2, "//go:cgo_ldflag %q\n", arg)
- }
- }
- }
- sort.Strings(flags)
- for _, flag := range flags {
- fmt.Fprintln(fflg, flag)
- }
- fflg.Close()
- // Write C main file for using gcc to resolve imports.
- fmt.Fprintf(fm, "int main() { return 0; }\n")
- if *importRuntimeCgo {
- fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*) __attribute__((unused)), void *a __attribute__((unused)), int c __attribute__((unused)), __SIZE_TYPE__ ctxt __attribute__((unused))) { }\n")
- fmt.Fprintf(fm, "__SIZE_TYPE__ _cgo_wait_runtime_init_done(void) { return 0; }\n")
- fmt.Fprintf(fm, "void _cgo_release_context(__SIZE_TYPE__ ctxt __attribute__((unused))) { }\n")
- fmt.Fprintf(fm, "char* _cgo_topofstack(void) { return (char*)0; }\n")
- } else {
- // If we're not importing runtime/cgo, we *are* runtime/cgo,
- // which provides these functions. We just need a prototype.
- fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*), void *a, int c, __SIZE_TYPE__ ctxt);\n")
- fmt.Fprintf(fm, "__SIZE_TYPE__ _cgo_wait_runtime_init_done(void);\n")
- fmt.Fprintf(fm, "void _cgo_release_context(__SIZE_TYPE__);\n")
- }
- fmt.Fprintf(fm, "void _cgo_allocate(void *a __attribute__((unused)), int c __attribute__((unused))) { }\n")
- fmt.Fprintf(fm, "void _cgo_panic(void *a __attribute__((unused)), int c __attribute__((unused))) { }\n")
- fmt.Fprintf(fm, "void _cgo_reginit(void) { }\n")
- // Write second Go output: definitions of _C_xxx.
- // In a separate file so that the import of "unsafe" does not
- // pollute the original file.
- fmt.Fprintf(fgo2, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
- fmt.Fprintf(fgo2, "package %s\n\n", p.PackageName)
- fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
- if !*gccgo && *importRuntimeCgo {
- fmt.Fprintf(fgo2, "import _ \"runtime/cgo\"\n\n")
- }
- if *importSyscall {
- fmt.Fprintf(fgo2, "import \"syscall\"\n\n")
- fmt.Fprintf(fgo2, "var _ syscall.Errno\n")
- }
- fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
- if !*gccgo {
- fmt.Fprintf(fgo2, "//go:linkname _Cgo_always_false runtime.cgoAlwaysFalse\n")
- fmt.Fprintf(fgo2, "var _Cgo_always_false bool\n")
- fmt.Fprintf(fgo2, "//go:linkname _Cgo_use runtime.cgoUse\n")
- fmt.Fprintf(fgo2, "func _Cgo_use(interface{})\n")
- }
- typedefNames := make([]string, 0, len(typedef))
- for name := range typedef {
- if name == "_Ctype_void" {
- // We provide an appropriate declaration for
- // _Ctype_void below (#39877).
- continue
- }
- typedefNames = append(typedefNames, name)
- }
- sort.Strings(typedefNames)
- for _, name := range typedefNames {
- def := typedef[name]
- if def.NotInHeap {
- fmt.Fprintf(fgo2, "//go:notinheap\n")
- }
- fmt.Fprintf(fgo2, "type %s ", name)
- // We don't have source info for these types, so write them out without source info.
- // Otherwise types would look like:
- //
- // type _Ctype_struct_cb struct {
- // //line :1
- // on_test *[0]byte
- // //line :1
- // }
- //
- // Which is not useful. Moreover we never override source info,
- // so subsequent source code uses the same source info.
- // Moreover, empty file name makes compile emit no source debug info at all.
- var buf bytes.Buffer
- noSourceConf.Fprint(&buf, fset, def.Go)
- if bytes.HasPrefix(buf.Bytes(), []byte("_Ctype_")) ||
- strings.HasPrefix(name, "_Ctype_enum_") ||
- strings.HasPrefix(name, "_Ctype_union_") {
- // This typedef is of the form `typedef a b` and should be an alias.
- fmt.Fprintf(fgo2, "= ")
- }
- fmt.Fprintf(fgo2, "%s", buf.Bytes())
- fmt.Fprintf(fgo2, "\n\n")
- }
- fmt.Fprintf(fgo2, "//go:notinheap\ntype _Ctype_void_notinheap struct{}\n\n")
- if *gccgo {
- fmt.Fprintf(fgo2, "type _Ctype_void byte\n")
- } else {
- fmt.Fprintf(fgo2, "type _Ctype_void [0]byte\n")
- }
- if *gccgo {
- fmt.Fprint(fgo2, gccgoGoProlog)
- fmt.Fprint(fc, p.cPrologGccgo())
- } else {
- fmt.Fprint(fgo2, goProlog)
- }
- if fc != nil {
- fmt.Fprintf(fc, "#line 1 \"cgo-generated-wrappers\"\n")
- }
- if fm != nil {
- fmt.Fprintf(fm, "#line 1 \"cgo-generated-wrappers\"\n")
- }
- gccgoSymbolPrefix := p.gccgoSymbolPrefix()
- cVars := make(map[string]bool)
- for _, key := range nameKeys(p.Name) {
- n := p.Name[key]
- if !n.IsVar() {
- continue
- }
- if !cVars[n.C] {
- if *gccgo {
- fmt.Fprintf(fc, "extern byte *%s;\n", n.C)
- } else {
- // Force a reference to all symbols so that
- // the external linker will add DT_NEEDED
- // entries as needed on ELF systems.
- // Treat function variables differently
- // to avoid type confict errors from LTO
- // (Link Time Optimization).
- if n.Kind == "fpvar" {
- fmt.Fprintf(fm, "extern void %s();\n", n.C)
- } else {
- fmt.Fprintf(fm, "extern char %s[];\n", n.C)
- fmt.Fprintf(fm, "void *_cgohack_%s = %s;\n\n", n.C, n.C)
- }
- fmt.Fprintf(fgo2, "//go:linkname __cgo_%s %s\n", n.C, n.C)
- fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", n.C)
- fmt.Fprintf(fgo2, "var __cgo_%s byte\n", n.C)
- }
- cVars[n.C] = true
- }
- var node ast.Node
- if n.Kind == "var" {
- node = &ast.StarExpr{X: n.Type.Go}
- } else if n.Kind == "fpvar" {
- node = n.Type.Go
- } else {
- panic(fmt.Errorf("invalid var kind %q", n.Kind))
- }
- if *gccgo {
- fmt.Fprintf(fc, `extern void *%s __asm__("%s.%s");`, n.Mangle, gccgoSymbolPrefix, gccgoToSymbol(n.Mangle))
- fmt.Fprintf(&gccgoInit, "\t%s = &%s;\n", n.Mangle, n.C)
- fmt.Fprintf(fc, "\n")
- }
- fmt.Fprintf(fgo2, "var %s ", n.Mangle)
- conf.Fprint(fgo2, fset, node)
- if !*gccgo {
- fmt.Fprintf(fgo2, " = (")
- conf.Fprint(fgo2, fset, node)
- fmt.Fprintf(fgo2, ")(unsafe.Pointer(&__cgo_%s))", n.C)
- }
- fmt.Fprintf(fgo2, "\n")
- }
- if *gccgo {
- fmt.Fprintf(fc, "\n")
- }
- for _, key := range nameKeys(p.Name) {
- n := p.Name[key]
- if n.Const != "" {
- fmt.Fprintf(fgo2, "const %s = %s\n", n.Mangle, n.Const)
- }
- }
- fmt.Fprintf(fgo2, "\n")
- callsMalloc := false
- for _, key := range nameKeys(p.Name) {
- n := p.Name[key]
- if n.FuncType != nil {
- p.writeDefsFunc(fgo2, n, &callsMalloc)
- }
- }
- fgcc := creat(*objDir + "_cgo_export.c")
- fgcch := creat(*objDir + "_cgo_export.h")
- if *gccgo {
- p.writeGccgoExports(fgo2, fm, fgcc, fgcch)
- } else {
- p.writeExports(fgo2, fm, fgcc, fgcch)
- }
- if callsMalloc && !*gccgo {
- fmt.Fprint(fgo2, strings.Replace(cMallocDefGo, "PREFIX", cPrefix, -1))
- fmt.Fprint(fgcc, strings.Replace(strings.Replace(cMallocDefC, "PREFIX", cPrefix, -1), "PACKED", p.packedAttribute(), -1))
- }
- if err := fgcc.Close(); err != nil {
- fatalf("%s", err)
- }
- if err := fgcch.Close(); err != nil {
- fatalf("%s", err)
- }
- if *exportHeader != "" && len(p.ExpFunc) > 0 {
- fexp := creat(*exportHeader)
- fgcch, err := os.Open(*objDir + "_cgo_export.h")
- if err != nil {
- fatalf("%s", err)
- }
- defer fgcch.Close()
- _, err = io.Copy(fexp, fgcch)
- if err != nil {
- fatalf("%s", err)
- }
- if err = fexp.Close(); err != nil {
- fatalf("%s", err)
- }
- }
- init := gccgoInit.String()
- if init != "" {
- // The init function does nothing but simple
- // assignments, so it won't use much stack space, so
- // it's OK to not split the stack. Splitting the stack
- // can run into a bug in clang (as of 2018-11-09):
- // this is a leaf function, and when clang sees a leaf
- // function it won't emit the split stack prologue for
- // the function. However, if this function refers to a
- // non-split-stack function, which will happen if the
- // cgo code refers to a C function not compiled with
- // -fsplit-stack, then the linker will think that it
- // needs to adjust the split stack prologue, but there
- // won't be one. Marking the function explicitly
- // no_split_stack works around this problem by telling
- // the linker that it's OK if there is no split stack
- // prologue.
- fmt.Fprintln(fc, "static void init(void) __attribute__ ((constructor, no_split_stack));")
- fmt.Fprintln(fc, "static void init(void) {")
- fmt.Fprint(fc, init)
- fmt.Fprintln(fc, "}")
- }
- }
- // elfImportedSymbols is like elf.File.ImportedSymbols, but it
- // includes weak symbols.
- //
- // A bug in some versions of LLD (at least LLD 8) cause it to emit
- // several pthreads symbols as weak, but we need to import those. See
- // issue #31912 or https://bugs.llvm.org/show_bug.cgi?id=42442.
- //
- // When doing external linking, we hand everything off to the external
- // linker, which will create its own dynamic symbol tables. For
- // internal linking, this may turn weak imports into strong imports,
- // which could cause dynamic linking to fail if a symbol really isn't
- // defined. However, the standard library depends on everything it
- // imports, and this is the primary use of dynamic symbol tables with
- // internal linking.
- func elfImportedSymbols(f *elf.File) []elf.ImportedSymbol {
- syms, _ := f.DynamicSymbols()
- var imports []elf.ImportedSymbol
- for _, s := range syms {
- if (elf.ST_BIND(s.Info) == elf.STB_GLOBAL || elf.ST_BIND(s.Info) == elf.STB_WEAK) && s.Section == elf.SHN_UNDEF {
- imports = append(imports, elf.ImportedSymbol{
- Name: s.Name,
- Library: s.Library,
- Version: s.Version,
- })
- }
- }
- return imports
- }
- func dynimport(obj string) {
- stdout := os.Stdout
- if *dynout != "" {
- f, err := os.Create(*dynout)
- if err != nil {
- fatalf("%s", err)
- }
- stdout = f
- }
- fmt.Fprintf(stdout, "package %s\n", *dynpackage)
- if f, err := elf.Open(obj); err == nil {
- if *dynlinker {
- // Emit the cgo_dynamic_linker line.
- if sec := f.Section(".interp"); sec != nil {
- if data, err := sec.Data(); err == nil && len(data) > 1 {
- // skip trailing \0 in data
- fmt.Fprintf(stdout, "//go:cgo_dynamic_linker %q\n", string(data[:len(data)-1]))
- }
- }
- }
- sym := elfImportedSymbols(f)
- for _, s := range sym {
- targ := s.Name
- if s.Version != "" {
- targ += "#" + s.Version
- }
- checkImportSymName(s.Name)
- checkImportSymName(targ)
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, targ, s.Library)
- }
- lib, _ := f.ImportedLibraries()
- for _, l := range lib {
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
- }
- return
- }
- if f, err := macho.Open(obj); err == nil {
- sym, _ := f.ImportedSymbols()
- for _, s := range sym {
- if len(s) > 0 && s[0] == '_' {
- s = s[1:]
- }
- checkImportSymName(s)
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s, s, "")
- }
- lib, _ := f.ImportedLibraries()
- for _, l := range lib {
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
- }
- return
- }
- if f, err := pe.Open(obj); err == nil {
- sym, _ := f.ImportedSymbols()
- for _, s := range sym {
- ss := strings.Split(s, ":")
- name := strings.Split(ss[0], "@")[0]
- checkImportSymName(name)
- checkImportSymName(ss[0])
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", name, ss[0], strings.ToLower(ss[1]))
- }
- return
- }
- if f, err := xcoff.Open(obj); err == nil {
- sym, err := f.ImportedSymbols()
- if err != nil {
- fatalf("cannot load imported symbols from XCOFF file %s: %v", obj, err)
- }
- for _, s := range sym {
- if s.Name == "runtime_rt0_go" || s.Name == "_rt0_ppc64_aix_lib" {
- // These symbols are imported by runtime/cgo but
- // must not be added to _cgo_import.go as there are
- // Go symbols.
- continue
- }
- checkImportSymName(s.Name)
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, s.Name, s.Library)
- }
- lib, err := f.ImportedLibraries()
- if err != nil {
- fatalf("cannot load imported libraries from XCOFF file %s: %v", obj, err)
- }
- for _, l := range lib {
- fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
- }
- return
- }
- fatalf("cannot parse %s as ELF, Mach-O, PE or XCOFF", obj)
- }
- // checkImportSymName checks a symbol name we are going to emit as part
- // of a //go:cgo_import_dynamic pragma. These names come from object
- // files, so they may be corrupt. We are going to emit them unquoted,
- // so while they don't need to be valid symbol names (and in some cases,
- // involving symbol versions, they won't be) they must contain only
- // graphic characters and must not contain Go comments.
- func checkImportSymName(s string) {
- for _, c := range s {
- if !unicode.IsGraphic(c) || unicode.IsSpace(c) {
- fatalf("dynamic symbol %q contains unsupported character", s)
- }
- }
- if strings.Index(s, "//") >= 0 || strings.Index(s, "/*") >= 0 {
- fatalf("dynamic symbol %q contains Go comment")
- }
- }
- // Construct a gcc struct matching the gc argument frame.
- // Assumes that in gcc, char is 1 byte, short 2 bytes, int 4 bytes, long long 8 bytes.
- // These assumptions are checked by the gccProlog.
- // Also assumes that gc convention is to word-align the
- // input and output parameters.
- func (p *Package) structType(n *Name) (string, int64) {
- var buf bytes.Buffer
- fmt.Fprint(&buf, "struct {\n")
- off := int64(0)
- for i, t := range n.FuncType.Params {
- if off%t.Align != 0 {
- pad := t.Align - off%t.Align
- fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
- off += pad
- }
- c := t.Typedef
- if c == "" {
- c = t.C.String()
- }
- fmt.Fprintf(&buf, "\t\t%s p%d;\n", c, i)
- off += t.Size
- }
- if off%p.PtrSize != 0 {
- pad := p.PtrSize - off%p.PtrSize
- fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
- off += pad
- }
- if t := n.FuncType.Result; t != nil {
- if off%t.Align != 0 {
- pad := t.Align - off%t.Align
- fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
- off += pad
- }
- fmt.Fprintf(&buf, "\t\t%s r;\n", t.C)
- off += t.Size
- }
- if off%p.PtrSize != 0 {
- pad := p.PtrSize - off%p.PtrSize
- fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
- off += pad
- }
- if off == 0 {
- fmt.Fprintf(&buf, "\t\tchar unused;\n") // avoid empty struct
- }
- fmt.Fprintf(&buf, "\t}")
- return buf.String(), off
- }
- func (p *Package) writeDefsFunc(fgo2 io.Writer, n *Name, callsMalloc *bool) {
- name := n.Go
- gtype := n.FuncType.Go
- void := gtype.Results == nil || len(gtype.Results.List) == 0
- if n.AddError {
- // Add "error" to return type list.
- // Type list is known to be 0 or 1 element - it's a C function.
- err := &ast.Field{Type: ast.NewIdent("error")}
- l := gtype.Results.List
- if len(l) == 0 {
- l = []*ast.Field{err}
- } else {
- l = []*ast.Field{l[0], err}
- }
- t := new(ast.FuncType)
- *t = *gtype
- t.Results = &ast.FieldList{List: l}
- gtype = t
- }
- // Go func declaration.
- d := &ast.FuncDecl{
- Name: ast.NewIdent(n.Mangle),
- Type: gtype,
- }
- // Builtins defined in the C prolog.
- inProlog := builtinDefs[name] != ""
- cname := fmt.Sprintf("_cgo%s%s", cPrefix, n.Mangle)
- paramnames := []string(nil)
- if d.Type.Params != nil {
- for i, param := range d.Type.Params.List {
- paramName := fmt.Sprintf("p%d", i)
- param.Names = []*ast.Ident{ast.NewIdent(paramName)}
- paramnames = append(paramnames, paramName)
- }
- }
- if *gccgo {
- // Gccgo style hooks.
- fmt.Fprint(fgo2, "\n")
- conf.Fprint(fgo2, fset, d)
- fmt.Fprint(fgo2, " {\n")
- if !inProlog {
- fmt.Fprint(fgo2, "\tdefer syscall.CgocallDone()\n")
- fmt.Fprint(fgo2, "\tsyscall.Cgocall()\n")
- }
- if n.AddError {
- fmt.Fprint(fgo2, "\tsyscall.SetErrno(0)\n")
- }
- fmt.Fprint(fgo2, "\t")
- if !void {
- fmt.Fprint(fgo2, "r := ")
- }
- fmt.Fprintf(fgo2, "%s(%s)\n", cname, strings.Join(paramnames, ", "))
- if n.AddError {
- fmt.Fprint(fgo2, "\te := syscall.GetErrno()\n")
- fmt.Fprint(fgo2, "\tif e != 0 {\n")
- fmt.Fprint(fgo2, "\t\treturn ")
- if !void {
- fmt.Fprint(fgo2, "r, ")
- }
- fmt.Fprint(fgo2, "e\n")
- fmt.Fprint(fgo2, "\t}\n")
- fmt.Fprint(fgo2, "\treturn ")
- if !void {
- fmt.Fprint(fgo2, "r, ")
- }
- fmt.Fprint(fgo2, "nil\n")
- } else if !void {
- fmt.Fprint(fgo2, "\treturn r\n")
- }
- fmt.Fprint(fgo2, "}\n")
- // declare the C function.
- fmt.Fprintf(fgo2, "//extern %s\n", cname)
- d.Name = ast.NewIdent(cname)
- if n.AddError {
- l := d.Type.Results.List
- d.Type.Results.List = l[:len(l)-1]
- }
- conf.Fprint(fgo2, fset, d)
- fmt.Fprint(fgo2, "\n")
- return
- }
- if inProlog {
- fmt.Fprint(fgo2, builtinDefs[name])
- if strings.Contains(builtinDefs[name], "_cgo_cmalloc") {
- *callsMalloc = true
- }
- return
- }
- // Wrapper calls into gcc, passing a pointer to the argument frame.
- fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", cname)
- fmt.Fprintf(fgo2, "//go:linkname __cgofn_%s %s\n", cname, cname)
- fmt.Fprintf(fgo2, "var __cgofn_%s byte\n", cname)
- fmt.Fprintf(fgo2, "var %s = unsafe.Pointer(&__cgofn_%s)\n", cname, cname)
- nret := 0
- if !void {
- d.Type.Results.List[0].Names = []*ast.Ident{ast.NewIdent("r1")}
- nret = 1
- }
- if n.AddError {
- d.Type.Results.List[nret].Names = []*ast.Ident{ast.NewIdent("r2")}
- }
- fmt.Fprint(fgo2, "\n")
- fmt.Fprint(fgo2, "//go:cgo_unsafe_args\n")
- conf.Fprint(fgo2, fset, d)
- fmt.Fprint(fgo2, " {\n")
- // NOTE: Using uintptr to hide from escape analysis.
- arg := "0"
- if len(paramnames) > 0 {
- arg = "uintptr(unsafe.Pointer(&p0))"
- } else if !void {
- arg = "uintptr(unsafe.Pointer(&r1))"
- }
- prefix := ""
- if n.AddError {
- prefix = "errno := "
- }
- fmt.Fprintf(fgo2, "\t%s_cgo_runtime_cgocall(%s, %s)\n", prefix, cname, arg)
- if n.AddError {
- fmt.Fprintf(fgo2, "\tif errno != 0 { r2 = syscall.Errno(errno) }\n")
- }
- fmt.Fprintf(fgo2, "\tif _Cgo_always_false {\n")
- if d.Type.Params != nil {
- for i := range d.Type.Params.List {
- fmt.Fprintf(fgo2, "\t\t_Cgo_use(p%d)\n", i)
- }
- }
- fmt.Fprintf(fgo2, "\t}\n")
- fmt.Fprintf(fgo2, "\treturn\n")
- fmt.Fprintf(fgo2, "}\n")
- }
- // writeOutput creates stubs for a specific source file to be compiled by gc
- func (p *Package) writeOutput(f *File, srcfile string) {
- base := srcfile
- if strings.HasSuffix(base, ".go") {
- base = base[0 : len(base)-3]
- }
- base = filepath.Base(base)
- fgo1 := creat(*objDir + base + ".cgo1.go")
- fgcc := creat(*objDir + base + ".cgo2.c")
- p.GoFiles = append(p.GoFiles, base+".cgo1.go")
- p.GccFiles = append(p.GccFiles, base+".cgo2.c")
- // Write Go output: Go input with rewrites of C.xxx to _C_xxx.
- fmt.Fprintf(fgo1, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
- fmt.Fprintf(fgo1, "//line %s:1:1\n", srcfile)
- fgo1.Write(f.Edit.Bytes())
- // While we process the vars and funcs, also write gcc output.
- // Gcc output starts with the preamble.
- fmt.Fprintf(fgcc, "%s\n", builtinProlog)
- fmt.Fprintf(fgcc, "%s\n", f.Preamble)
- fmt.Fprintf(fgcc, "%s\n", gccProlog)
- fmt.Fprintf(fgcc, "%s\n", tsanProlog)
- fmt.Fprintf(fgcc, "%s\n", msanProlog)
- for _, key := range nameKeys(f.Name) {
- n := f.Name[key]
- if n.FuncType != nil {
- p.writeOutputFunc(fgcc, n)
- }
- }
- fgo1.Close()
- fgcc.Close()
- }
- // fixGo converts the internal Name.Go field into the name we should show
- // to users in error messages. There's only one for now: on input we rewrite
- // C.malloc into C._CMalloc, so change it back here.
- func fixGo(name string) string {
- if name == "_CMalloc" {
- return "malloc"
- }
- return name
- }
- var isBuiltin = map[string]bool{
- "_Cfunc_CString": true,
- "_Cfunc_CBytes": true,
- "_Cfunc_GoString": true,
- "_Cfunc_GoStringN": true,
- "_Cfunc_GoBytes": true,
- "_Cfunc__CMalloc": true,
- }
- func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
- name := n.Mangle
- if isBuiltin[name] || p.Written[name] {
- // The builtins are already defined in the C prolog, and we don't
- // want to duplicate function definitions we've already done.
- return
- }
- p.Written[name] = true
- if *gccgo {
- p.writeGccgoOutputFunc(fgcc, n)
- return
- }
- ctype, _ := p.structType(n)
- // Gcc wrapper unpacks the C argument struct
- // and calls the actual C function.
- fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
- if n.AddError {
- fmt.Fprintf(fgcc, "int\n")
- } else {
- fmt.Fprintf(fgcc, "void\n")
- }
- fmt.Fprintf(fgcc, "_cgo%s%s(void *v)\n", cPrefix, n.Mangle)
- fmt.Fprintf(fgcc, "{\n")
- if n.AddError {
- fmt.Fprintf(fgcc, "\tint _cgo_errno;\n")
- }
- // We're trying to write a gcc struct that matches gc's layout.
- // Use packed attribute to force no padding in this struct in case
- // gcc has different packing requirements.
- fmt.Fprintf(fgcc, "\t%s %v *_cgo_a = v;\n", ctype, p.packedAttribute())
- if n.FuncType.Result != nil {
- // Save the stack top for use below.
- fmt.Fprintf(fgcc, "\tchar *_cgo_stktop = _cgo_topofstack();\n")
- }
- tr := n.FuncType.Result
- if tr != nil {
- fmt.Fprintf(fgcc, "\t__typeof__(_cgo_a->r) _cgo_r;\n")
- }
- fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
- if n.AddError {
- fmt.Fprintf(fgcc, "\terrno = 0;\n")
- }
- fmt.Fprintf(fgcc, "\t")
- if tr != nil {
- fmt.Fprintf(fgcc, "_cgo_r = ")
- if c := tr.C.String(); c[len(c)-1] == '*' {
- fmt.Fprint(fgcc, "(__typeof__(_cgo_a->r)) ")
- }
- }
- if n.Kind == "macro" {
- fmt.Fprintf(fgcc, "%s;\n", n.C)
- } else {
- fmt.Fprintf(fgcc, "%s(", n.C)
- for i := range n.FuncType.Params {
- if i > 0 {
- fmt.Fprintf(fgcc, ", ")
- }
- fmt.Fprintf(fgcc, "_cgo_a->p%d", i)
- }
- fmt.Fprintf(fgcc, ");\n")
- }
- if n.AddError {
- fmt.Fprintf(fgcc, "\t_cgo_errno = errno;\n")
- }
- fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
- if n.FuncType.Result != nil {
- // The cgo call may have caused a stack copy (via a callback).
- // Adjust the return value pointer appropriately.
- fmt.Fprintf(fgcc, "\t_cgo_a = (void*)((char*)_cgo_a + (_cgo_topofstack() - _cgo_stktop));\n")
- // Save the return value.
- fmt.Fprintf(fgcc, "\t_cgo_a->r = _cgo_r;\n")
- // The return value is on the Go stack. If we are using msan,
- // and if the C value is partially or completely uninitialized,
- // the assignment will mark the Go stack as uninitialized.
- // The Go compiler does not update msan for changes to the
- // stack. It is possible that the stack will remain
- // uninitialized, and then later be used in a way that is
- // visible to msan, possibly leading to a false positive.
- // Mark the stack space as written, to avoid this problem.
- // See issue 26209.
- fmt.Fprintf(fgcc, "\t_cgo_msan_write(&_cgo_a->r, sizeof(_cgo_a->r));\n")
- }
- if n.AddError {
- fmt.Fprintf(fgcc, "\treturn _cgo_errno;\n")
- }
- fmt.Fprintf(fgcc, "}\n")
- fmt.Fprintf(fgcc, "\n")
- }
- // Write out a wrapper for a function when using gccgo. This is a
- // simple wrapper that just calls the real function. We only need a
- // wrapper to support static functions in the prologue--without a
- // wrapper, we can't refer to the function, since the reference is in
- // a different file.
- func (p *Package) writeGccgoOutputFunc(fgcc *os.File, n *Name) {
- fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
- if t := n.FuncType.Result; t != nil {
- fmt.Fprintf(fgcc, "%s\n", t.C.String())
- } else {
- fmt.Fprintf(fgcc, "void\n")
- }
- fmt.Fprintf(fgcc, "_cgo%s%s(", cPrefix, n.Mangle)
- for i, t := range n.FuncType.Params {
- if i > 0 {
- fmt.Fprintf(fgcc, ", ")
- }
- c := t.Typedef
- if c == "" {
- c = t.C.String()
- }
- fmt.Fprintf(fgcc, "%s p%d", c, i)
- }
- fmt.Fprintf(fgcc, ")\n")
- fmt.Fprintf(fgcc, "{\n")
- if t := n.FuncType.Result; t != nil {
- fmt.Fprintf(fgcc, "\t%s _cgo_r;\n", t.C.String())
- }
- fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
- fmt.Fprintf(fgcc, "\t")
- if t := n.FuncType.Result; t != nil {
- fmt.Fprintf(fgcc, "_cgo_r = ")
- // Cast to void* to avoid warnings due to omitted qualifiers.
- if c := t.C.String(); c[len(c)-1] == '*' {
- fmt.Fprintf(fgcc, "(void*)")
- }
- }
- if n.Kind == "macro" {
- fmt.Fprintf(fgcc, "%s;\n", n.C)
- } else {
- fmt.Fprintf(fgcc, "%s(", n.C)
- for i := range n.FuncType.Params {
- if i > 0 {
- fmt.Fprintf(fgcc, ", ")
- }
- fmt.Fprintf(fgcc, "p%d", i)
- }
- fmt.Fprintf(fgcc, ");\n")
- }
- fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
- if t := n.FuncType.Result; t != nil {
- fmt.Fprintf(fgcc, "\treturn ")
- // Cast to void* to avoid warnings due to omitted qualifiers
- // and explicit incompatible struct types.
- if c := t.C.String(); c[len(c)-1] == '*' {
- fmt.Fprintf(fgcc, "(void*)")
- }
- fmt.Fprintf(fgcc, "_cgo_r;\n")
- }
- fmt.Fprintf(fgcc, "}\n")
- fmt.Fprintf(fgcc, "\n")
- }
- // packedAttribute returns host compiler struct attribute that will be
- // used to match gc's struct layout. For example, on 386 Windows,
- // gcc wants to 8-align int64s, but gc does not.
- // Use __gcc_struct__ to work around https://gcc.gnu.org/PR52991 on x86,
- // and https://golang.org/issue/5603.
- func (p *Package) packedAttribute() string {
- s := "__attribute__((__packed__"
- if !p.GccIsClang && (goarch == "amd64" || goarch == "386") {
- s += ", __gcc_struct__"
- }
- return s + "))"
- }
- // exportParamName returns the value of param as it should be
- // displayed in a c header file. If param contains any non-ASCII
- // characters, this function will return the character p followed by
- // the value of position; otherwise, this function will return the
- // value of param.
- func exportParamName(param string, position int) string {
- if param == "" {
- return fmt.Sprintf("p%d", position)
- }
- pname := param
- for i := 0; i < len(param); i++ {
- if param[i] > unicode.MaxASCII {
- pname = fmt.Sprintf("p%d", position)
- break
- }
- }
- return pname
- }
- // Write out the various stubs we need to support functions exported
- // from Go so that they are callable from C.
- func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
- p.writeExportHeader(fgcch)
- fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
- fmt.Fprintf(fgcc, "#include <stdlib.h>\n")
- fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n\n")
- // We use packed structs, but they are always aligned.
- // The pragmas and address-of-packed-member are only recognized as
- // warning groups in clang 4.0+, so ignore unknown pragmas first.
- fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n")
- fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wpragmas\"\n")
- fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Waddress-of-packed-member\"\n")
- fmt.Fprintf(fgcc, "extern void crosscall2(void (*fn)(void *), void *, int, __SIZE_TYPE__);\n")
- fmt.Fprintf(fgcc, "extern __SIZE_TYPE__ _cgo_wait_runtime_init_done(void);\n")
- fmt.Fprintf(fgcc, "extern void _cgo_release_context(__SIZE_TYPE__);\n\n")
- fmt.Fprintf(fgcc, "extern char* _cgo_topofstack(void);")
- fmt.Fprintf(fgcc, "%s\n", tsanProlog)
- fmt.Fprintf(fgcc, "%s\n", msanProlog)
- for _, exp := range p.ExpFunc {
- fn := exp.Func
- // Construct a struct that will be used to communicate
- // arguments from C to Go. The C and Go definitions
- // just have to agree. The gcc struct will be compiled
- // with __attribute__((packed)) so all padding must be
- // accounted for explicitly.
- ctype := "struct {\n"
- gotype := new(bytes.Buffer)
- fmt.Fprintf(gotype, "struct {\n")
- off := int64(0)
- npad := 0
- argField := func(typ ast.Expr, namePat string, args ...interface{}) {
- name := fmt.Sprintf(namePat, args...)
- t := p.cgoType(typ)
- if off%t.Align != 0 {
- pad := t.Align - off%t.Align
- ctype += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
- off += pad
- npad++
- }
- ctype += fmt.Sprintf("\t\t%s %s;\n", t.C, name)
- fmt.Fprintf(gotype, "\t\t%s ", name)
- noSourceConf.Fprint(gotype, fset, typ)
- fmt.Fprintf(gotype, "\n")
- off += t.Size
- }
- if fn.Recv != nil {
- argField(fn.Recv.List[0].Type, "recv")
- }
- fntype := fn.Type
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- argField(atype, "p%d", i)
- })
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- argField(atype, "r%d", i)
- })
- if ctype == "struct {\n" {
- ctype += "\t\tchar unused;\n" // avoid empty struct
- }
- ctype += "\t}"
- fmt.Fprintf(gotype, "\t}")
- // Get the return type of the wrapper function
- // compiled by gcc.
- gccResult := ""
- if fntype.Results == nil || len(fntype.Results.List) == 0 {
- gccResult = "void"
- } else if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
- gccResult = p.cgoType(fntype.Results.List[0].Type).C.String()
- } else {
- fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
- fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- fmt.Fprintf(fgcch, "\t%s r%d;", p.cgoType(atype).C, i)
- if len(aname) > 0 {
- fmt.Fprintf(fgcch, " /* %s */", aname)
- }
- fmt.Fprint(fgcch, "\n")
- })
- fmt.Fprintf(fgcch, "};\n")
- gccResult = "struct " + exp.ExpName + "_return"
- }
- // Build the wrapper function compiled by gcc.
- gccExport := ""
- if goos == "windows" {
- gccExport = "__declspec(dllexport) "
- }
- s := fmt.Sprintf("%s%s %s(", gccExport, gccResult, exp.ExpName)
- if fn.Recv != nil {
- s += p.cgoType(fn.Recv.List[0].Type).C.String()
- s += " recv"
- }
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 || fn.Recv != nil {
- s += ", "
- }
- s += fmt.Sprintf("%s %s", p.cgoType(atype).C, exportParamName(aname, i))
- })
- s += ")"
- if len(exp.Doc) > 0 {
- fmt.Fprintf(fgcch, "\n%s", exp.Doc)
- if !strings.HasSuffix(exp.Doc, "\n") {
- fmt.Fprint(fgcch, "\n")
- }
- }
- fmt.Fprintf(fgcch, "extern %s;\n", s)
- fmt.Fprintf(fgcc, "extern void _cgoexp%s_%s(void *);\n", cPrefix, exp.ExpName)
- fmt.Fprintf(fgcc, "\nCGO_NO_SANITIZE_THREAD")
- fmt.Fprintf(fgcc, "\n%s\n", s)
- fmt.Fprintf(fgcc, "{\n")
- fmt.Fprintf(fgcc, "\t__SIZE_TYPE__ _cgo_ctxt = _cgo_wait_runtime_init_done();\n")
- // The results part of the argument structure must be
- // initialized to 0 so the write barriers generated by
- // the assignments to these fields in Go are safe.
- //
- // We use a local static variable to get the zeroed
- // value of the argument type. This avoids including
- // string.h for memset, and is also robust to C++
- // types with constructors. Both GCC and LLVM optimize
- // this into just zeroing _cgo_a.
- fmt.Fprintf(fgcc, "\ttypedef %s %v _cgo_argtype;\n", ctype, p.packedAttribute())
- fmt.Fprintf(fgcc, "\tstatic _cgo_argtype _cgo_zero;\n")
- fmt.Fprintf(fgcc, "\t_cgo_argtype _cgo_a = _cgo_zero;\n")
- if gccResult != "void" && (len(fntype.Results.List) > 1 || len(fntype.Results.List[0].Names) > 1) {
- fmt.Fprintf(fgcc, "\t%s r;\n", gccResult)
- }
- if fn.Recv != nil {
- fmt.Fprintf(fgcc, "\t_cgo_a.recv = recv;\n")
- }
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- fmt.Fprintf(fgcc, "\t_cgo_a.p%d = %s;\n", i, exportParamName(aname, i))
- })
- fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
- fmt.Fprintf(fgcc, "\tcrosscall2(_cgoexp%s_%s, &_cgo_a, %d, _cgo_ctxt);\n", cPrefix, exp.ExpName, off)
- fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
- fmt.Fprintf(fgcc, "\t_cgo_release_context(_cgo_ctxt);\n")
- if gccResult != "void" {
- if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
- fmt.Fprintf(fgcc, "\treturn _cgo_a.r0;\n")
- } else {
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- fmt.Fprintf(fgcc, "\tr.r%d = _cgo_a.r%d;\n", i, i)
- })
- fmt.Fprintf(fgcc, "\treturn r;\n")
- }
- }
- fmt.Fprintf(fgcc, "}\n")
- // In internal linking mode, the Go linker sees both
- // the C wrapper written above and the Go wrapper it
- // references. Hence, export the C wrapper (e.g., for
- // if we're building a shared object). The Go linker
- // will resolve the C wrapper's reference to the Go
- // wrapper without a separate export.
- fmt.Fprintf(fgo2, "//go:cgo_export_dynamic %s\n", exp.ExpName)
- // cgo_export_static refers to a symbol by its linker
- // name, so set the linker name of the Go wrapper.
- fmt.Fprintf(fgo2, "//go:linkname _cgoexp%s_%s _cgoexp%s_%s\n", cPrefix, exp.ExpName, cPrefix, exp.ExpName)
- // In external linking mode, the Go linker sees the Go
- // wrapper, but not the C wrapper. For this case,
- // export the Go wrapper so the host linker can
- // resolve the reference from the C wrapper to the Go
- // wrapper.
- fmt.Fprintf(fgo2, "//go:cgo_export_static _cgoexp%s_%s\n", cPrefix, exp.ExpName)
- // Build the wrapper function compiled by cmd/compile.
- // This unpacks the argument struct above and calls the Go function.
- fmt.Fprintf(fgo2, "func _cgoexp%s_%s(a *%s) {\n", cPrefix, exp.ExpName, gotype)
- fmt.Fprintf(fm, "void _cgoexp%s_%s(void* p){}\n", cPrefix, exp.ExpName)
- fmt.Fprintf(fgo2, "\t")
- if gccResult != "void" {
- // Write results back to frame.
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 {
- fmt.Fprintf(fgo2, ", ")
- }
- fmt.Fprintf(fgo2, "a.r%d", i)
- })
- fmt.Fprintf(fgo2, " = ")
- }
- if fn.Recv != nil {
- fmt.Fprintf(fgo2, "a.recv.")
- }
- fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 {
- fmt.Fprint(fgo2, ", ")
- }
- fmt.Fprintf(fgo2, "a.p%d", i)
- })
- fmt.Fprint(fgo2, ")\n")
- if gccResult != "void" {
- // Verify that any results don't contain any
- // Go pointers.
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- if !p.hasPointer(nil, atype, false) {
- return
- }
- fmt.Fprintf(fgo2, "\t_cgoCheckResult(a.r%d)\n", i)
- })
- }
- fmt.Fprint(fgo2, "}\n")
- }
- fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
- }
- // Write out the C header allowing C code to call exported gccgo functions.
- func (p *Package) writeGccgoExports(fgo2, fm, fgcc, fgcch io.Writer) {
- gccgoSymbolPrefix := p.gccgoSymbolPrefix()
- p.writeExportHeader(fgcch)
- fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
- fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n")
- fmt.Fprintf(fgcc, "%s\n", gccgoExportFileProlog)
- fmt.Fprintf(fgcc, "%s\n", tsanProlog)
- fmt.Fprintf(fgcc, "%s\n", msanProlog)
- for _, exp := range p.ExpFunc {
- fn := exp.Func
- fntype := fn.Type
- cdeclBuf := new(bytes.Buffer)
- resultCount := 0
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) { resultCount++ })
- switch resultCount {
- case 0:
- fmt.Fprintf(cdeclBuf, "void")
- case 1:
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- t := p.cgoType(atype)
- fmt.Fprintf(cdeclBuf, "%s", t.C)
- })
- default:
- // Declare a result struct.
- fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
- fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- t := p.cgoType(atype)
- fmt.Fprintf(fgcch, "\t%s r%d;", t.C, i)
- if len(aname) > 0 {
- fmt.Fprintf(fgcch, " /* %s */", aname)
- }
- fmt.Fprint(fgcch, "\n")
- })
- fmt.Fprintf(fgcch, "};\n")
- fmt.Fprintf(cdeclBuf, "struct %s_return", exp.ExpName)
- }
- cRet := cdeclBuf.String()
- cdeclBuf = new(bytes.Buffer)
- fmt.Fprintf(cdeclBuf, "(")
- if fn.Recv != nil {
- fmt.Fprintf(cdeclBuf, "%s recv", p.cgoType(fn.Recv.List[0].Type).C.String())
- }
- // Function parameters.
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 || fn.Recv != nil {
- fmt.Fprintf(cdeclBuf, ", ")
- }
- t := p.cgoType(atype)
- fmt.Fprintf(cdeclBuf, "%s p%d", t.C, i)
- })
- fmt.Fprintf(cdeclBuf, ")")
- cParams := cdeclBuf.String()
- if len(exp.Doc) > 0 {
- fmt.Fprintf(fgcch, "\n%s", exp.Doc)
- }
- fmt.Fprintf(fgcch, "extern %s %s%s;\n", cRet, exp.ExpName, cParams)
- // We need to use a name that will be exported by the
- // Go code; otherwise gccgo will make it static and we
- // will not be able to link against it from the C
- // code.
- goName := "Cgoexp_" + exp.ExpName
- fmt.Fprintf(fgcc, `extern %s %s %s __asm__("%s.%s");`, cRet, goName, cParams, gccgoSymbolPrefix, gccgoToSymbol(goName))
- fmt.Fprint(fgcc, "\n")
- fmt.Fprint(fgcc, "\nCGO_NO_SANITIZE_THREAD\n")
- fmt.Fprintf(fgcc, "%s %s %s {\n", cRet, exp.ExpName, cParams)
- if resultCount > 0 {
- fmt.Fprintf(fgcc, "\t%s r;\n", cRet)
- }
- fmt.Fprintf(fgcc, "\tif(_cgo_wait_runtime_init_done)\n")
- fmt.Fprintf(fgcc, "\t\t_cgo_wait_runtime_init_done();\n")
- fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
- fmt.Fprint(fgcc, "\t")
- if resultCount > 0 {
- fmt.Fprint(fgcc, "r = ")
- }
- fmt.Fprintf(fgcc, "%s(", goName)
- if fn.Recv != nil {
- fmt.Fprint(fgcc, "recv")
- }
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 || fn.Recv != nil {
- fmt.Fprintf(fgcc, ", ")
- }
- fmt.Fprintf(fgcc, "p%d", i)
- })
- fmt.Fprint(fgcc, ");\n")
- fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
- if resultCount > 0 {
- fmt.Fprint(fgcc, "\treturn r;\n")
- }
- fmt.Fprint(fgcc, "}\n")
- // Dummy declaration for _cgo_main.c
- fmt.Fprintf(fm, `char %s[1] __asm__("%s.%s");`, goName, gccgoSymbolPrefix, gccgoToSymbol(goName))
- fmt.Fprint(fm, "\n")
- // For gccgo we use a wrapper function in Go, in order
- // to call CgocallBack and CgocallBackDone.
- // This code uses printer.Fprint, not conf.Fprint,
- // because we don't want //line comments in the middle
- // of the function types.
- fmt.Fprint(fgo2, "\n")
- fmt.Fprintf(fgo2, "func %s(", goName)
- if fn.Recv != nil {
- fmt.Fprint(fgo2, "recv ")
- printer.Fprint(fgo2, fset, fn.Recv.List[0].Type)
- }
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 || fn.Recv != nil {
- fmt.Fprintf(fgo2, ", ")
- }
- fmt.Fprintf(fgo2, "p%d ", i)
- printer.Fprint(fgo2, fset, atype)
- })
- fmt.Fprintf(fgo2, ")")
- if resultCount > 0 {
- fmt.Fprintf(fgo2, " (")
- forFieldList(fntype.Results,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 {
- fmt.Fprint(fgo2, ", ")
- }
- printer.Fprint(fgo2, fset, atype)
- })
- fmt.Fprint(fgo2, ")")
- }
- fmt.Fprint(fgo2, " {\n")
- fmt.Fprint(fgo2, "\tsyscall.CgocallBack()\n")
- fmt.Fprint(fgo2, "\tdefer syscall.CgocallBackDone()\n")
- fmt.Fprint(fgo2, "\t")
- if resultCount > 0 {
- fmt.Fprint(fgo2, "return ")
- }
- if fn.Recv != nil {
- fmt.Fprint(fgo2, "recv.")
- }
- fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
- forFieldList(fntype.Params,
- func(i int, aname string, atype ast.Expr) {
- if i > 0 {
- fmt.Fprint(fgo2, ", ")
- }
- fmt.Fprintf(fgo2, "p%d", i)
- })
- fmt.Fprint(fgo2, ")\n")
- fmt.Fprint(fgo2, "}\n")
- }
- fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
- }
- // writeExportHeader writes out the start of the _cgo_export.h file.
- func (p *Package) writeExportHeader(fgcch io.Writer) {
- fmt.Fprintf(fgcch, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
- pkg := *importPath
- if pkg == "" {
- pkg = p.PackagePath
- }
- fmt.Fprintf(fgcch, "/* package %s */\n\n", pkg)
- fmt.Fprintf(fgcch, "%s\n", builtinExportProlog)
- // Remove absolute paths from #line comments in the preamble.
- // They aren't useful for people using the header file,
- // and they mean that the header files change based on the
- // exact location of GOPATH.
- re := regexp.MustCompile(`(?m)^(#line\s+[0-9]+\s+")[^"]*[/\\]([^"]*")`)
- preamble := re.ReplaceAllString(p.Preamble, "$1$2")
- fmt.Fprintf(fgcch, "/* Start of preamble from import \"C\" comments. */\n\n")
- fmt.Fprintf(fgcch, "%s\n", preamble)
- fmt.Fprintf(fgcch, "\n/* End of preamble from import \"C\" comments. */\n\n")
- fmt.Fprintf(fgcch, "%s\n", p.gccExportHeaderProlog())
- }
- // gccgoToSymbol converts a name to a mangled symbol for gccgo.
- func gccgoToSymbol(ppath string) string {
- if gccgoMangler == nil {
- var err error
- cmd := os.Getenv("GCCGO")
- if cmd == "" {
- cmd, err = exec.LookPath("gccgo")
- if err != nil {
- fatalf("unable to locate gccgo: %v", err)
- }
- }
- gccgoMangler, err = pkgpath.ToSymbolFunc(cmd, *objDir)
- if err != nil {
- fatalf("%v", err)
- }
- }
- return gccgoMangler(ppath)
- }
- // Return the package prefix when using gccgo.
- func (p *Package) gccgoSymbolPrefix() string {
- if !*gccgo {
- return ""
- }
- if *gccgopkgpath != "" {
- return gccgoToSymbol(*gccgopkgpath)
- }
- if *gccgoprefix == "" && p.PackageName == "main" {
- return "main"
- }
- prefix := gccgoToSymbol(*gccgoprefix)
- if prefix == "" {
- prefix = "go"
- }
- return prefix + "." + p.PackageName
- }
- // Call a function for each entry in an ast.FieldList, passing the
- // index into the list, the name if any, and the type.
- func forFieldList(fl *ast.FieldList, fn func(int, string, ast.Expr)) {
- if fl == nil {
- return
- }
- i := 0
- for _, r := range fl.List {
- if r.Names == nil {
- fn(i, "", r.Type)
- i++
- } else {
- for _, n := range r.Names {
- fn(i, n.Name, r.Type)
- i++
- }
- }
- }
- }
- func c(repr string, args ...interface{}) *TypeRepr {
- return &TypeRepr{repr, args}
- }
- // Map predeclared Go types to Type.
- var goTypes = map[string]*Type{
- "bool": {Size: 1, Align: 1, C: c("GoUint8")},
- "byte": {Size: 1, Align: 1, C: c("GoUint8")},
- "int": {Size: 0, Align: 0, C: c("GoInt")},
- "uint": {Size: 0, Align: 0, C: c("GoUint")},
- "rune": {Size: 4, Align: 4, C: c("GoInt32")},
- "int8": {Size: 1, Align: 1, C: c("GoInt8")},
- "uint8": {Size: 1, Align: 1, C: c("GoUint8")},
- "int16": {Size: 2, Align: 2, C: c("GoInt16")},
- "uint16": {Size: 2, Align: 2, C: c("GoUint16")},
- "int32": {Size: 4, Align: 4, C: c("GoInt32")},
- "uint32": {Size: 4, Align: 4, C: c("GoUint32")},
- "int64": {Size: 8, Align: 8, C: c("GoInt64")},
- "uint64": {Size: 8, Align: 8, C: c("GoUint64")},
- "float32": {Size: 4, Align: 4, C: c("GoFloat32")},
- "float64": {Size: 8, Align: 8, C: c("GoFloat64")},
- "complex64": {Size: 8, Align: 4, C: c("GoComplex64")},
- "complex128": {Size: 16, Align: 8, C: c("GoComplex128")},
- }
- // Map an ast type to a Type.
- func (p *Package) cgoType(e ast.Expr) *Type {
- switch t := e.(type) {
- case *ast.StarExpr:
- x := p.cgoType(t.X)
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("%s*", x.C)}
- case *ast.ArrayType:
- if t.Len == nil {
- // Slice: pointer, len, cap.
- return &Type{Size: p.PtrSize * 3, Align: p.PtrSize, C: c("GoSlice")}
- }
- // Non-slice array types are not supported.
- case *ast.StructType:
- // Not supported.
- case *ast.FuncType:
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
- case *ast.InterfaceType:
- return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
- case *ast.MapType:
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoMap")}
- case *ast.ChanType:
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoChan")}
- case *ast.Ident:
- // Look up the type in the top level declarations.
- // TODO: Handle types defined within a function.
- for _, d := range p.Decl {
- gd, ok := d.(*ast.GenDecl)
- if !ok || gd.Tok != token.TYPE {
- continue
- }
- for _, spec := range gd.Specs {
- ts, ok := spec.(*ast.TypeSpec)
- if !ok {
- continue
- }
- if ts.Name.Name == t.Name {
- return p.cgoType(ts.Type)
- }
- }
- }
- if def := typedef[t.Name]; def != nil {
- return def
- }
- if t.Name == "uintptr" {
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoUintptr")}
- }
- if t.Name == "string" {
- // The string data is 1 pointer + 1 (pointer-sized) int.
- return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoString")}
- }
- if t.Name == "error" {
- return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
- }
- if r, ok := goTypes[t.Name]; ok {
- if r.Size == 0 { // int or uint
- rr := new(Type)
- *rr = *r
- rr.Size = p.IntSize
- rr.Align = p.IntSize
- r = rr
- }
- if r.Align > p.PtrSize {
- r.Align = p.PtrSize
- }
- return r
- }
- error_(e.Pos(), "unrecognized Go type %s", t.Name)
- return &Type{Size: 4, Align: 4, C: c("int")}
- case *ast.SelectorExpr:
- id, ok := t.X.(*ast.Ident)
- if ok && id.Name == "unsafe" && t.Sel.Name == "Pointer" {
- return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
- }
- }
- error_(e.Pos(), "Go type not supported in export: %s", gofmt(e))
- return &Type{Size: 4, Align: 4, C: c("int")}
- }
- const gccProlog = `
- #line 1 "cgo-gcc-prolog"
- /*
- If x and y are not equal, the type will be invalid
- (have a negative array count) and an inscrutable error will come
- out of the compiler and hopefully mention "name".
- */
- #define __cgo_compile_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2UL+1UL];
- /* Check at compile time that the sizes we use match our expectations. */
- #define __cgo_size_assert(t, n) __cgo_compile_assert_eq(sizeof(t), (size_t)n, _cgo_sizeof_##t##_is_not_##n)
- __cgo_size_assert(char, 1)
- __cgo_size_assert(short, 2)
- __cgo_size_assert(int, 4)
- typedef long long __cgo_long_long;
- __cgo_size_assert(__cgo_long_long, 8)
- __cgo_size_assert(float, 4)
- __cgo_size_assert(double, 8)
- extern char* _cgo_topofstack(void);
- /*
- We use packed structs, but they are always aligned.
- The pragmas and address-of-packed-member are only recognized as warning
- groups in clang 4.0+, so ignore unknown pragmas first.
- */
- #pragma GCC diagnostic ignored "-Wunknown-pragmas"
- #pragma GCC diagnostic ignored "-Wpragmas"
- #pragma GCC diagnostic ignored "-Waddress-of-packed-member"
- #include <errno.h>
- #include <string.h>
- `
- // Prologue defining TSAN functions in C.
- const noTsanProlog = `
- #define CGO_NO_SANITIZE_THREAD
- #define _cgo_tsan_acquire()
- #define _cgo_tsan_release()
- `
- // This must match the TSAN code in runtime/cgo/libcgo.h.
- // This is used when the code is built with the C/C++ Thread SANitizer,
- // which is not the same as the Go race detector.
- // __tsan_acquire tells TSAN that we are acquiring a lock on a variable,
- // in this case _cgo_sync. __tsan_release releases the lock.
- // (There is no actual lock, we are just telling TSAN that there is.)
- //
- // When we call from Go to C we call _cgo_tsan_acquire.
- // When the C function returns we call _cgo_tsan_release.
- // Similarly, when C calls back into Go we call _cgo_tsan_release
- // and then call _cgo_tsan_acquire when we return to C.
- // These calls tell TSAN that there is a serialization point at the C call.
- //
- // This is necessary because TSAN, which is a C/C++ tool, can not see
- // the synchronization in the Go code. Without these calls, when
- // multiple goroutines call into C code, TSAN does not understand
- // that the calls are properly synchronized on the Go side.
- //
- // To be clear, if the calls are not properly synchronized on the Go side,
- // we will be hiding races. But when using TSAN on mixed Go C/C++ code
- // it is more important to avoid false positives, which reduce confidence
- // in the tool, than to avoid false negatives.
- const yesTsanProlog = `
- #line 1 "cgo-tsan-prolog"
- #define CGO_NO_SANITIZE_THREAD __attribute__ ((no_sanitize_thread))
- long long _cgo_sync __attribute__ ((common));
- extern void __tsan_acquire(void*);
- extern void __tsan_release(void*);
- __attribute__ ((unused))
- static void _cgo_tsan_acquire() {
- __tsan_acquire(&_cgo_sync);
- }
- __attribute__ ((unused))
- static void _cgo_tsan_release() {
- __tsan_release(&_cgo_sync);
- }
- `
- // Set to yesTsanProlog if we see -fsanitize=thread in the flags for gcc.
- var tsanProlog = noTsanProlog
- // noMsanProlog is a prologue defining an MSAN function in C.
- // This is used when not compiling with -fsanitize=memory.
- const noMsanProlog = `
- #define _cgo_msan_write(addr, sz)
- `
- // yesMsanProlog is a prologue defining an MSAN function in C.
- // This is used when compiling with -fsanitize=memory.
- // See the comment above where _cgo_msan_write is called.
- const yesMsanProlog = `
- extern void __msan_unpoison(const volatile void *, size_t);
- #define _cgo_msan_write(addr, sz) __msan_unpoison((addr), (sz))
- `
- // msanProlog is set to yesMsanProlog if we see -fsanitize=memory in the flags
- // for the C compiler.
- var msanProlog = noMsanProlog
- const builtinProlog = `
- #line 1 "cgo-builtin-prolog"
- #include <stddef.h> /* for ptrdiff_t and size_t below */
- /* Define intgo when compiling with GCC. */
- typedef ptrdiff_t intgo;
- #define GO_CGO_GOSTRING_TYPEDEF
- typedef struct { const char *p; intgo n; } _GoString_;
- typedef struct { char *p; intgo n; intgo c; } _GoBytes_;
- _GoString_ GoString(char *p);
- _GoString_ GoStringN(char *p, int l);
- _GoBytes_ GoBytes(void *p, int n);
- char *CString(_GoString_);
- void *CBytes(_GoBytes_);
- void *_CMalloc(size_t);
- __attribute__ ((unused))
- static size_t _GoStringLen(_GoString_ s) { return (size_t)s.n; }
- __attribute__ ((unused))
- static const char *_GoStringPtr(_GoString_ s) { return s.p; }
- `
- const goProlog = `
- //go:linkname _cgo_runtime_cgocall runtime.cgocall
- func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
- //go:linkname _cgoCheckPointer runtime.cgoCheckPointer
- func _cgoCheckPointer(interface{}, interface{})
- //go:linkname _cgoCheckResult runtime.cgoCheckResult
- func _cgoCheckResult(interface{})
- `
- const gccgoGoProlog = `
- func _cgoCheckPointer(interface{}, interface{})
- func _cgoCheckResult(interface{})
- `
- const goStringDef = `
- //go:linkname _cgo_runtime_gostring runtime.gostring
- func _cgo_runtime_gostring(*_Ctype_char) string
- func _Cfunc_GoString(p *_Ctype_char) string {
- return _cgo_runtime_gostring(p)
- }
- `
- const goStringNDef = `
- //go:linkname _cgo_runtime_gostringn runtime.gostringn
- func _cgo_runtime_gostringn(*_Ctype_char, int) string
- func _Cfunc_GoStringN(p *_Ctype_char, l _Ctype_int) string {
- return _cgo_runtime_gostringn(p, int(l))
- }
- `
- const goBytesDef = `
- //go:linkname _cgo_runtime_gobytes runtime.gobytes
- func _cgo_runtime_gobytes(unsafe.Pointer, int) []byte
- func _Cfunc_GoBytes(p unsafe.Pointer, l _Ctype_int) []byte {
- return _cgo_runtime_gobytes(p, int(l))
- }
- `
- const cStringDef = `
- func _Cfunc_CString(s string) *_Ctype_char {
- p := _cgo_cmalloc(uint64(len(s)+1))
- pp := (*[1<<30]byte)(p)
- copy(pp[:], s)
- pp[len(s)] = 0
- return (*_Ctype_char)(p)
- }
- `
- const cBytesDef = `
- func _Cfunc_CBytes(b []byte) unsafe.Pointer {
- p := _cgo_cmalloc(uint64(len(b)))
- pp := (*[1<<30]byte)(p)
- copy(pp[:], b)
- return p
- }
- `
- const cMallocDef = `
- func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
- return _cgo_cmalloc(uint64(n))
- }
- `
- var builtinDefs = map[string]string{
- "GoString": goStringDef,
- "GoStringN": goStringNDef,
- "GoBytes": goBytesDef,
- "CString": cStringDef,
- "CBytes": cBytesDef,
- "_CMalloc": cMallocDef,
- }
- // Definitions for C.malloc in Go and in C. We define it ourselves
- // since we call it from functions we define, such as C.CString.
- // Also, we have historically ensured that C.malloc does not return
- // nil even for an allocation of 0.
- const cMallocDefGo = `
- //go:cgo_import_static _cgoPREFIX_Cfunc__Cmalloc
- //go:linkname __cgofn__cgoPREFIX_Cfunc__Cmalloc _cgoPREFIX_Cfunc__Cmalloc
- var __cgofn__cgoPREFIX_Cfunc__Cmalloc byte
- var _cgoPREFIX_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgoPREFIX_Cfunc__Cmalloc)
- //go:linkname runtime_throw runtime.throw
- func runtime_throw(string)
- //go:cgo_unsafe_args
- func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
- _cgo_runtime_cgocall(_cgoPREFIX_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
- if r1 == nil {
- runtime_throw("runtime: C malloc failed")
- }
- return
- }
- `
- // cMallocDefC defines the C version of C.malloc for the gc compiler.
- // It is defined here because C.CString and friends need a definition.
- // We define it by hand, rather than simply inventing a reference to
- // C.malloc, because <stdlib.h> may not have been included.
- // This is approximately what writeOutputFunc would generate, but
- // skips the cgo_topofstack code (which is only needed if the C code
- // calls back into Go). This also avoids returning nil for an
- // allocation of 0 bytes.
- const cMallocDefC = `
- CGO_NO_SANITIZE_THREAD
- void _cgoPREFIX_Cfunc__Cmalloc(void *v) {
- struct {
- unsigned long long p0;
- void *r1;
- } PACKED *a = v;
- void *ret;
- _cgo_tsan_acquire();
- ret = malloc(a->p0);
- if (ret == 0 && a->p0 == 0) {
- ret = malloc(1);
- }
- a->r1 = ret;
- _cgo_tsan_release();
- }
- `
- func (p *Package) cPrologGccgo() string {
- r := strings.NewReplacer(
- "PREFIX", cPrefix,
- "GCCGOSYMBOLPREF", p.gccgoSymbolPrefix(),
- "_cgoCheckPointer", gccgoToSymbol("_cgoCheckPointer"),
- "_cgoCheckResult", gccgoToSymbol("_cgoCheckResult"))
- return r.Replace(cPrologGccgo)
- }
- const cPrologGccgo = `
- #line 1 "cgo-c-prolog-gccgo"
- #include <stdint.h>
- #include <stdlib.h>
- #include <string.h>
- typedef unsigned char byte;
- typedef intptr_t intgo;
- struct __go_string {
- const unsigned char *__data;
- intgo __length;
- };
- typedef struct __go_open_array {
- void* __values;
- intgo __count;
- intgo __capacity;
- } Slice;
- struct __go_string __go_byte_array_to_string(const void* p, intgo len);
- struct __go_open_array __go_string_to_byte_array (struct __go_string str);
- extern void runtime_throw(const char *);
- const char *_cgoPREFIX_Cfunc_CString(struct __go_string s) {
- char *p = malloc(s.__length+1);
- if(p == NULL)
- runtime_throw("runtime: C malloc failed");
- memmove(p, s.__data, s.__length);
- p[s.__length] = 0;
- return p;
- }
- void *_cgoPREFIX_Cfunc_CBytes(struct __go_open_array b) {
- char *p = malloc(b.__count);
- if(p == NULL)
- runtime_throw("runtime: C malloc failed");
- memmove(p, b.__values, b.__count);
- return p;
- }
- struct __go_string _cgoPREFIX_Cfunc_GoString(char *p) {
- intgo len = (p != NULL) ? strlen(p) : 0;
- return __go_byte_array_to_string(p, len);
- }
- struct __go_string _cgoPREFIX_Cfunc_GoStringN(char *p, int32_t n) {
- return __go_byte_array_to_string(p, n);
- }
- Slice _cgoPREFIX_Cfunc_GoBytes(char *p, int32_t n) {
- struct __go_string s = { (const unsigned char *)p, n };
- return __go_string_to_byte_array(s);
- }
- void *_cgoPREFIX_Cfunc__CMalloc(size_t n) {
- void *p = malloc(n);
- if(p == NULL && n == 0)
- p = malloc(1);
- if(p == NULL)
- runtime_throw("runtime: C malloc failed");
- return p;
- }
- struct __go_type_descriptor;
- typedef struct __go_empty_interface {
- const struct __go_type_descriptor *__type_descriptor;
- void *__object;
- } Eface;
- extern void runtimeCgoCheckPointer(Eface, Eface)
- __asm__("runtime.cgoCheckPointer")
- __attribute__((weak));
- extern void localCgoCheckPointer(Eface, Eface)
- __asm__("GCCGOSYMBOLPREF._cgoCheckPointer");
- void localCgoCheckPointer(Eface ptr, Eface arg) {
- if(runtimeCgoCheckPointer) {
- runtimeCgoCheckPointer(ptr, arg);
- }
- }
- extern void runtimeCgoCheckResult(Eface)
- __asm__("runtime.cgoCheckResult")
- __attribute__((weak));
- extern void localCgoCheckResult(Eface)
- __asm__("GCCGOSYMBOLPREF._cgoCheckResult");
- void localCgoCheckResult(Eface val) {
- if(runtimeCgoCheckResult) {
- runtimeCgoCheckResult(val);
- }
- }
- `
- // builtinExportProlog is a shorter version of builtinProlog,
- // to be put into the _cgo_export.h file.
- // For historical reasons we can't use builtinProlog in _cgo_export.h,
- // because _cgo_export.h defines GoString as a struct while builtinProlog
- // defines it as a function. We don't change this to avoid unnecessarily
- // breaking existing code.
- // The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
- // error if a Go file with a cgo comment #include's the export header
- // generated by a different package.
- const builtinExportProlog = `
- #line 1 "cgo-builtin-export-prolog"
- #include <stddef.h> /* for ptrdiff_t below */
- #ifndef GO_CGO_EXPORT_PROLOGUE_H
- #define GO_CGO_EXPORT_PROLOGUE_H
- #ifndef GO_CGO_GOSTRING_TYPEDEF
- typedef struct { const char *p; ptrdiff_t n; } _GoString_;
- #endif
- #endif
- `
- func (p *Package) gccExportHeaderProlog() string {
- return strings.Replace(gccExportHeaderProlog, "GOINTBITS", fmt.Sprint(8*p.IntSize), -1)
- }
- // gccExportHeaderProlog is written to the exported header, after the
- // import "C" comment preamble but before the generated declarations
- // of exported functions. This permits the generated declarations to
- // use the type names that appear in goTypes, above.
- //
- // The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
- // error if a Go file with a cgo comment #include's the export header
- // generated by a different package. Unfortunately GoString means two
- // different things: in this prolog it means a C name for the Go type,
- // while in the prolog written into the start of the C code generated
- // from a cgo-using Go file it means the C.GoString function. There is
- // no way to resolve this conflict, but it also doesn't make much
- // difference, as Go code never wants to refer to the latter meaning.
- const gccExportHeaderProlog = `
- /* Start of boilerplate cgo prologue. */
- #line 1 "cgo-gcc-export-header-prolog"
- #ifndef GO_CGO_PROLOGUE_H
- #define GO_CGO_PROLOGUE_H
- typedef signed char GoInt8;
- typedef unsigned char GoUint8;
- typedef short GoInt16;
- typedef unsigned short GoUint16;
- typedef int GoInt32;
- typedef unsigned int GoUint32;
- typedef long long GoInt64;
- typedef unsigned long long GoUint64;
- typedef GoIntGOINTBITS GoInt;
- typedef GoUintGOINTBITS GoUint;
- typedef __SIZE_TYPE__ GoUintptr;
- typedef float GoFloat32;
- typedef double GoFloat64;
- typedef float _Complex GoComplex64;
- typedef double _Complex GoComplex128;
- /*
- static assertion to make sure the file is being used on architecture
- at least with matching size of GoInt.
- */
- typedef char _check_for_GOINTBITS_bit_pointer_matching_GoInt[sizeof(void*)==GOINTBITS/8 ? 1:-1];
- #ifndef GO_CGO_GOSTRING_TYPEDEF
- typedef _GoString_ GoString;
- #endif
- typedef void *GoMap;
- typedef void *GoChan;
- typedef struct { void *t; void *v; } GoInterface;
- typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
- #endif
- /* End of boilerplate cgo prologue. */
- #ifdef __cplusplus
- extern "C" {
- #endif
- `
- // gccExportHeaderEpilog goes at the end of the generated header file.
- const gccExportHeaderEpilog = `
- #ifdef __cplusplus
- }
- #endif
- `
- // gccgoExportFileProlog is written to the _cgo_export.c file when
- // using gccgo.
- // We use weak declarations, and test the addresses, so that this code
- // works with older versions of gccgo.
- const gccgoExportFileProlog = `
- #line 1 "cgo-gccgo-export-file-prolog"
- extern _Bool runtime_iscgo __attribute__ ((weak));
- static void GoInit(void) __attribute__ ((constructor));
- static void GoInit(void) {
- if(&runtime_iscgo)
- runtime_iscgo = 1;
- }
- extern __SIZE_TYPE__ _cgo_wait_runtime_init_done(void) __attribute__ ((weak));
- `
|