blob: 5693052fdf1baaa6aa6ad61d2bcec934367e8d03 [file] [log] [blame]
// 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 gc
// a function named init is a special case.
// it is called by the initialization before
// main is run. to make it unique within a
// package and also uncallable, the name,
// normally "pkg.init", is altered to "pkg.init.1".
var renameinit_initgen int
func renameinit() *Sym {
renameinit_initgen++
return lookupN("init.", renameinit_initgen)
}
// hand-craft the following initialization code
// var initdone· uint8 (1)
// func init() { (2)
// if initdone· > 1 { (3)
// return (3a)
// }
// if initdone· == 1 { (4)
// throw() (4a)
// }
// initdone· = 1 (5)
// // over all matching imported symbols
// <pkg>.init() (6)
// { <init stmts> } (7)
// init.<n>() // if any (8)
// initdone· = 2 (9)
// return (10)
// }
func anyinit(n []*Node) bool {
// are there any interesting init statements
for _, ln := range n {
switch ln.Op {
case ODCLFUNC, ODCLCONST, ODCLTYPE, OEMPTY:
break
case OAS, OASWB:
if isblank(ln.Left) && candiscard(ln.Right) {
break
}
fallthrough
default:
return true
}
}
// is this main
if localpkg.Name == "main" {
return true
}
// is there an explicit init function
s := lookup("init.1")
if s.Def != nil {
return true
}
// are there any imported init functions
for _, s := range initSyms {
if s.Def != nil {
return true
}
}
// then none
return false
}
func fninit(n []*Node) {
nf := initfix(n)
if !anyinit(nf) {
return
}
var r []*Node
// (1)
gatevar := newname(lookup("initdone·"))
addvar(gatevar, Types[TUINT8], PEXTERN)
// (2)
Maxarg = 0
fn := nod(ODCLFUNC, nil, nil)
initsym := lookup("init")
fn.Func.Nname = newname(initsym)
fn.Func.Nname.Name.Defn = fn
fn.Func.Nname.Name.Param.Ntype = nod(OTFUNC, nil, nil)
declare(fn.Func.Nname, PFUNC)
funchdr(fn)
// (3)
a := nod(OIF, nil, nil)
a.Left = nod(OGT, gatevar, nodintconst(1))
a.Likely = 1
r = append(r, a)
// (3a)
a.Nbody.Set1(nod(ORETURN, nil, nil))
// (4)
b := nod(OIF, nil, nil)
b.Left = nod(OEQ, gatevar, nodintconst(1))
// this actually isn't likely, but code layout is better
// like this: no JMP needed after the call.
b.Likely = 1
r = append(r, b)
// (4a)
b.Nbody.Set1(nod(OCALL, syslook("throwinit"), nil))
// (5)
a = nod(OAS, gatevar, nodintconst(1))
r = append(r, a)
// (6)
for _, s := range initSyms {
if s.Def != nil && s != initsym {
// could check that it is fn of no args/returns
a = nod(OCALL, s.Def, nil)
r = append(r, a)
}
}
// (7)
r = append(r, nf...)
// (8)
// could check that it is fn of no args/returns
for i := 1; ; i++ {
s := lookupN("init.", i)
if s.Def == nil {
break
}
a = nod(OCALL, s.Def, nil)
r = append(r, a)
}
// (9)
a = nod(OAS, gatevar, nodintconst(2))
r = append(r, a)
// (10)
a = nod(ORETURN, nil, nil)
r = append(r, a)
exportsym(fn.Func.Nname)
fn.Nbody.Set(r)
funcbody(fn)
Curfn = fn
fn = typecheck(fn, Etop)
typecheckslice(r, Etop)
Curfn = nil
funccompile(fn)
}