Skip to content

G
go
Commit 6327e8dc authored by Jeremy Jackins's avatar Jeremy Jackins Committed by Brad Fitzpatrick
Browse files
Options

cmd/compile/internal/gc: update old c-style comments 

Update old c-style comments to look like Go comments. Also replace some
lingering references to old .c files that don't exist anymore.

Change-Id: I72b2407a40fc76c23e9048643e0622fd70b4cf90
Reviewed-on: https://go-review.googlesource.com/16190
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
parent 6410e67a
Show whitespace changes
Inline Side-by-side
Showing with 527 additions and 852 deletions
src/cmd/compile/internal/gc/align.go
View file @ 6327e8dc
......@@ -6,12 +6,8 @@ package gc
import "cmd/internal/obj"
/*
* machine size and rounding
* alignment is dictated around
* the size of a pointer, set in betypeinit
* (see ../6g/galign.c).
*/
// machine size and rounding alignment is dictated around
// the size of a pointer, set in betypeinit (see ../amd64/galign.go).
var defercalc int
func Rnd(o int64, r int64) int64 {
......@@ -68,7 +64,7 @@ func widstruct(errtype *Type, t *Type, o int64, flag int) int64 {
f.Width = o // really offset for TFIELD
if f.Nname != nil {
// this same stackparam logic is in addrescapes
// in typecheck.c. usually addrescapes runs after
// in typecheck.go. usually addrescapes runs after
// widstruct, in which case we could drop this,
// but function closure functions are the exception.
if f.Nname.Name.Param.Stackparam != nil {
......@@ -158,7 +154,7 @@ func dowidth(t *Type) {
case TFUNC, TCHAN, TMAP, TSTRING:
break
/* simtype == 0 during bootstrap */
// simtype == 0 during bootstrap
default:
if Simtype[t.Etype] != 0 {
et = int32(Simtype[t.Etype])
......@@ -170,7 +166,7 @@ func dowidth(t *Type) {
default:
Fatalf("dowidth: unknown type: %v", t)
/* compiler-specific stuff */
// compiler-specific stuff
case TINT8, TUINT8, TBOOL:
// bool is int8
w = 1
......@@ -333,23 +329,21 @@ func dowidth(t *Type) {
}
}
/*
* when a type's width should be known, we call checkwidth
* to compute it. during a declaration like
*
* type T *struct { next T }
*
* it is necessary to defer the calculation of the struct width
* until after T has been initialized to be a pointer to that struct.
* similarly, during import processing structs may be used
* before their definition. in those situations, calling
* defercheckwidth() stops width calculations until
* resumecheckwidth() is called, at which point all the
* checkwidths that were deferred are executed.
* dowidth should only be called when the type's size
* is needed immediately. checkwidth makes sure the
* size is evaluated eventually.
*/
// when a type's width should be known, we call checkwidth
// to compute it. during a declaration like
//
// type T *struct { next T }
//
// it is necessary to defer the calculation of the struct width
// until after T has been initialized to be a pointer to that struct.
// similarly, during import processing structs may be used
// before their definition. in those situations, calling
// defercheckwidth() stops width calculations until
// resumecheckwidth() is called, at which point all the
// checkwidths that were deferred are executed.
// dowidth should only be called when the type's size
// is needed immediately. checkwidth makes sure the
// size is evaluated eventually.
type TypeList struct {
t *Type
next *TypeList
......@@ -469,9 +463,7 @@ func typeinit() {
Issigned[TINT32] = true
Issigned[TINT64] = true
/*
* initialize okfor
*/
// initialize okfor
for i := 0; i < NTYPE; i++ {
if Isint[i] || i == TIDEAL {
okforeq[i] = true
......@@ -599,10 +591,10 @@ func typeinit() {
mpatofix(Maxintval[TUINT32], "0xffffffff")
mpatofix(Maxintval[TUINT64], "0xffffffffffffffff")
/* f is valid float if min < f < max. (min and max are not themselves valid.) */
mpatoflt(maxfltval[TFLOAT32], "33554431p103") /* 2^24-1 p (127-23) + 1/2 ulp*/
// f is valid float if min < f < max. (min and max are not themselves valid.)
mpatoflt(maxfltval[TFLOAT32], "33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
mpatoflt(minfltval[TFLOAT32], "-33554431p103")
mpatoflt(maxfltval[TFLOAT64], "18014398509481983p970") /* 2^53-1 p (1023-52) + 1/2 ulp */
mpatoflt(maxfltval[TFLOAT64], "18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
mpatoflt(minfltval[TFLOAT64], "-18014398509481983p970")
maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
......@@ -610,23 +602,23 @@ func typeinit() {
maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
minfltval[TCOMPLEX128] = minfltval[TFLOAT64]
/* for walk to use in error messages */
// for walk to use in error messages
Types[TFUNC] = functype(nil, nil, nil)
/* types used in front end */
// types used in front end
// types[TNIL] got set early in lexinit
Types[TIDEAL] = typ(TIDEAL)
Types[TINTER] = typ(TINTER)
/* simple aliases */
// simple aliases
Simtype[TMAP] = uint8(Tptr)
Simtype[TCHAN] = uint8(Tptr)
Simtype[TFUNC] = uint8(Tptr)
Simtype[TUNSAFEPTR] = uint8(Tptr)
/* pick up the backend thearch.typedefs */
// pick up the backend thearch.typedefs
var s1 *Sym
var etype int
var sameas int
......@@ -678,9 +670,7 @@ func typeinit() {
itable.Type = Types[TUINT8]
}
/*
* compute total size of f's in/out arguments.
*/
// compute total size of f's in/out arguments.
func Argsize(t *Type) int {
var save Iter
var x int64
......
src/cmd/compile/internal/gc/bv.go
View file @ 6327e8dc
......@@ -56,7 +56,7 @@ func (b *bulkBvec) next() Bvec {
return out
}
/* difference */
// difference
func bvandnot(dst Bvec, src1 Bvec, src2 Bvec) {
for i, x := range src1.b {
dst.b[i] = x &^ src2.b[i]
......@@ -151,14 +151,14 @@ func bvnot(bv Bvec) {
}
}
/* union */
// union
func bvor(dst Bvec, src1 Bvec, src2 Bvec) {
for i, x := range src1.b {
dst.b[i] = x | src2.b[i]
}
}
/* intersection */
// intersection
func bvand(dst Bvec, src1 Bvec, src2 Bvec) {
for i, x := range src1.b {
dst.b[i] = x & src2.b[i]
......
src/cmd/compile/internal/gc/cgen.go
View file @ 6327e8dc
......@@ -9,12 +9,10 @@ import (
"fmt"
)
/*
* generate:
* res = n;
* simplifies and calls Thearch.Gmove.
* if wb is true, need to emit write barriers.
*/
// generate:
// res = n;
// simplifies and calls Thearch.Gmove.
// if wb is true, need to emit write barriers.
func Cgen(n, res *Node) {
cgen_wb(n, res, false)
}
......@@ -687,22 +685,20 @@ func cgen_wb(n, res *Node, wb bool) {
return
/*
* put simplest on right - we'll generate into left
* and then adjust it using the computation of right.
* constants and variables have the same ullman
* count, so look for constants specially.
*
* an integer constant we can use as an immediate
* is simpler than a variable - we can use the immediate
* in the adjustment instruction directly - so it goes
* on the right.
*
* other constants, like big integers or floating point
* constants, require a mov into a register, so those
* might as well go on the left, so we can reuse that
* register for the computation.
*/
// put simplest on right - we'll generate into left
// and then adjust it using the computation of right.
// constants and variables have the same ullman
// count, so look for constants specially.
//
// an integer constant we can use as an immediate
// is simpler than a variable - we can use the immediate
// in the adjustment instruction directly - so it goes
// on the right.
//
// other constants, like big integers or floating point
// constants, require a mov into a register, so those
// might as well go on the left, so we can reuse that
// register for the computation.
sbop: // symmetric binary
if nl.Ullman < nr.Ullman || (nl.Ullman == nr.Ullman && (Smallintconst(nl) || (nr.Op == OLITERAL && !Smallintconst(nr)))) {
nl, nr = nr, nl
......@@ -909,11 +905,9 @@ func Mfree(n *Node) {
}
}
/*
* allocate a register (reusing res if possible) and generate
* a = n
* The caller must call Regfree(a).
*/
// allocate a register (reusing res if possible) and generate
// a = n
// The caller must call Regfree(a).
func Cgenr(n *Node, a *Node, res *Node) {
if Debug['g'] != 0 {
Dump("cgenr-n", n)
......@@ -949,12 +943,10 @@ func Cgenr(n *Node, a *Node, res *Node) {
}
}
/*
* allocate a register (reusing res if possible) and generate
* a = &n
* The caller must call Regfree(a).
* The generated code checks that the result is not nil.
*/
// allocate a register (reusing res if possible) and generate
// a = &n
// The caller must call Regfree(a).
// The generated code checks that the result is not nil.
func Agenr(n *Node, a *Node, res *Node) {
if Debug['g'] != 0 {
Dump("\nagenr-n", n)
......@@ -1468,11 +1460,9 @@ func log2(n uint64) int {
return x
}
/*
* generate:
* res = &n;
* The generated code checks that the result is not nil.
*/
// generate:
// res = &n;
// The generated code checks that the result is not nil.
func Agen(n *Node, res *Node) {
if Debug['g'] != 0 {
Dump("\nagen-res", res)
......@@ -2219,11 +2209,9 @@ func stkof(n *Node) int64 {
return -1000 // not on stack
}
/*
* block copy:
* memmove(&ns, &n, w);
* if wb is true, needs write barrier.
*/
// block copy:
// memmove(&ns, &n, w);
// if wb is true, needs write barrier.
func sgen_wb(n *Node, ns *Node, w int64, wb bool) {
if Debug['g'] != 0 {
op := "sgen"
......@@ -2301,15 +2289,13 @@ func sgen_wb(n *Node, ns *Node, w int64, wb bool) {
Thearch.Blockcopy(n, ns, osrc, odst, w)
}
/*
* generate:
* call f
* proc=-1 normal call but no return
* proc=0 normal call
* proc=1 goroutine run in new proc
* proc=2 defer call save away stack
* proc=3 normal call to C pointer (not Go func value)
*/
// generate:
// call f
// proc=-1 normal call but no return
// proc=0 normal call
// proc=1 goroutine run in new proc
// proc=2 defer call save away stack
// proc=3 normal call to C pointer (not Go func value)
func Ginscall(f *Node, proc int) {
if f.Type != nil {
extra := int32(0)
......@@ -2395,10 +2381,8 @@ func Ginscall(f *Node, proc int) {
}
}
/*
* n is call to interface method.
* generate res = n.
*/
// n is call to interface method.
// generate res = n.
func cgen_callinter(n *Node, res *Node, proc int) {
i := n.Left
if i.Op != ODOTINTER {
......@@ -2468,12 +2452,10 @@ func cgen_callinter(n *Node, res *Node, proc int) {
Regfree(&nodo)
}
/*
* generate function call;
* proc=0 normal call
* proc=1 goroutine run in new proc
* proc=2 defer call save away stack
*/
// generate function call;
// proc=0 normal call
// proc=1 goroutine run in new proc
// proc=2 defer call save away stack
func cgen_call(n *Node, proc int) {
if n == nil {
return
......@@ -2519,11 +2501,9 @@ func cgen_call(n *Node, proc int) {
Ginscall(n.Left, proc)
}
/*
* call to n has already been generated.
* generate:
* res = return value from call.
*/
// call to n has already been generated.
// generate:
// res = return value from call.
func cgen_callret(n *Node, res *Node) {
t := n.Left.Type
if t.Etype == TPTR32 || t.Etype == TPTR64 {
......@@ -2546,11 +2526,9 @@ func cgen_callret(n *Node, res *Node) {
Cgen_as(res, &nod)
}
/*
* call to n has already been generated.
* generate:
* res = &return value from call.
*/
// call to n has already been generated.
// generate:
// res = &return value from call.
func cgen_aret(n *Node, res *Node) {
t := n.Left.Type
if Isptr[t.Etype] {
......@@ -2581,10 +2559,8 @@ func cgen_aret(n *Node, res *Node) {
}
}
/*
* generate return.
* n->left is assignments to return values.
*/
// generate return.
// n->left is assignments to return values.
func cgen_ret(n *Node) {
if n != nil {
Genlist(n.List) // copy out args
......@@ -2601,11 +2577,9 @@ func cgen_ret(n *Node) {
}
}
/*
* generate division according to op, one of:
* res = nl / nr
* res = nl % nr
*/
// generate division according to op, one of:
// res = nl / nr
// res = nl % nr
func cgen_div(op int, nl *Node, nr *Node, res *Node) {
var w int
......
src/cmd/compile/internal/gc/closure.go
View file @ 6327e8dc
......@@ -9,9 +9,7 @@ import (
"fmt"
)
/*
* function literals aka closures
*/
// function literals aka closures
func closurehdr(ntype *Node) {
var name *Node
var a *Node
......@@ -179,10 +177,8 @@ func closurename(n *Node) *Sym {
}
func makeclosure(func_ *Node) *Node {
/*
* wrap body in external function
* that begins by reading closure parameters.
*/
// wrap body in external function
// that begins by reading closure parameters.
xtype := Nod(OTFUNC, nil, nil)
xtype.List = func_.List
......
src/cmd/compile/internal/gc/const.go
View file @ 6327e8dc
......@@ -59,10 +59,8 @@ func (n *Node) Bool() bool {
return n.Val().U.(bool)
}
/*
* truncate float literal fv to 32-bit or 64-bit precision
* according to type; return truncated value.
*/
// truncate float literal fv to 32-bit or 64-bit precision
// according to type; return truncated value.
func truncfltlit(oldv *Mpflt, t *Type) *Mpflt {
if t == nil {
return oldv
......@@ -90,19 +88,15 @@ func truncfltlit(oldv *Mpflt, t *Type) *Mpflt {
return fv
}
/*
* convert n, if literal, to type t.
* implicit conversion.
*/
// convert n, if literal, to type t.
// implicit conversion.
func Convlit(np **Node, t *Type) {
convlit1(np, t, false)
}
/*
* convert n, if literal, to type t.
* return a new node if necessary
* (if n is a named constant, can't edit n->type directly).
*/
// convert n, if literal, to type t.
// return a new node if necessary
//(if n is a named constant, can't edit n->type directly).
func convlit1(np **Node, t *Type, explicit bool) {
n := *np
if n == nil || t == nil || n.Type == nil || isideal(t) || n.Type == t {
......@@ -501,9 +495,7 @@ func saveorig(n *Node) *Node {
return n.Orig
}
/*
* if n is constant, rewrite as OLITERAL node.
*/
// if n is constant, rewrite as OLITERAL node.
func evconst(n *Node) {
// pick off just the opcodes that can be
// constant evaluated.
......@@ -1300,12 +1292,10 @@ num:
return
}
/*
* defaultlit on both nodes simultaneously;
* if they're both ideal going in they better
* get the same type going out.
* force means must assign concrete (non-ideal) type.
*/
// defaultlit on both nodes simultaneously;
// if they're both ideal going in they better
// get the same type going out.
// force means must assign concrete (non-ideal) type.
func defaultlit2(lp **Node, rp **Node, force int) {
l := *lp
r := *rp
......@@ -1406,10 +1396,8 @@ func nonnegconst(n *Node) int {
return -1
}
/*
* convert x to type et and back to int64
* for sign extension and truncation.
*/
// convert x to type et and back to int64
// for sign extension and truncation.
func iconv(x int64, et int) int64 {
switch et {
case TINT8:
......
src/cmd/compile/internal/gc/dcl.go
View file @ 6327e8dc
......@@ -23,9 +23,7 @@ func dflag() bool {
return true
}
/*
* declaration stack & operations
*/
// declaration stack & operations
func dcopy(a *Sym, b *Sym) {
a.Pkg = b.Pkg
a.Name = b.Name
......@@ -149,9 +147,7 @@ func redeclare(s *Sym, where string) {
var vargen int
/*
* declare individual names - var, typ, const
*/
// declare individual names - var, typ, const
var declare_typegen int
......@@ -236,10 +232,8 @@ func addvar(n *Node, t *Type, ctxt uint8) {
n.Type = t
}
/*
* declare variables from grammar
* new_name_list (type | [type] = expr_list)
*/
// declare variables from grammar
// new_name_list (type | [type] = expr_list)
func variter(vl *NodeList, t *Node, el *NodeList) *NodeList {
var init *NodeList
doexpr := el != nil
......@@ -302,10 +296,8 @@ func variter(vl *NodeList, t *Node, el *NodeList) *NodeList {
return init
}
/*
* declare constants from grammar
* new_name_list [[type] = expr_list]
*/
// declare constants from grammar
// new_name_list [[type] = expr_list]
func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
lno := int32(0) // default is to leave line number alone in listtreecopy
if cl == nil {
......@@ -350,10 +342,8 @@ func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
return vv
}
/*
* this generates a new name node,
* typically for labels or other one-off names.
*/
// this generates a new name node,
// typically for labels or other one-off names.
func newname(s *Sym) *Node {
if s == nil {
Fatalf("newname nil")
......@@ -377,10 +367,8 @@ func newfuncname(s *Sym) *Node {
return n
}
/*
* this generates a new name node for a name
* being declared.
*/
// this generates a new name node for a name
// being declared.
func dclname(s *Sym) *Node {
n := newname(s)
n.Op = ONONAME // caller will correct it
......@@ -400,12 +388,10 @@ func typenod(t *Type) *Node {
return t.Nod
}
/*
* this will return an old name
* that has already been pushed on the
* declaration list. a diagnostic is
* generated if no name has been defined.
*/
// this will return an old name
// that has already been pushed on the
// declaration list. a diagnostic is
// generated if no name has been defined.
func oldname(s *Sym) *Node {
n := s.Def
if n == nil {
......@@ -450,9 +436,7 @@ func oldname(s *Sym) *Node {
return n
}
/*
* := declarations
*/
// := declarations
func colasname(n *Node) bool {
switch n.Op {
case ONAME,
......@@ -532,10 +516,8 @@ func colas(left *NodeList, right *NodeList, lno int32) *Node {
return as
}
/*
* declare the arguments in an
* interface field declaration.
*/
// declare the arguments in an
// interface field declaration.
func ifacedcl(n *Node) {
if n.Op != ODCLFIELD || n.Right == nil {
Fatalf("ifacedcl")
......@@ -563,12 +545,10 @@ func ifacedcl(n *Node) {
funcbody(n)
}
/*
* declare the function proper
* and declare the arguments.
* called in extern-declaration context
* returns in auto-declaration context.
*/
// declare the function proper
// and declare the arguments.
// called in extern-declaration context
// returns in auto-declaration context.
func funchdr(n *Node) {
// change the declaration context from extern to auto
if Funcdepth == 0 && dclcontext != PEXTERN {
......@@ -688,11 +668,9 @@ func funcargs(nt *Node) {
}
}
/*
* Same as funcargs, except run over an already constructed TFUNC.
* This happens during import, where the hidden_fndcl rule has
* used functype directly to parse the function's type.
*/
// Same as funcargs, except run over an already constructed TFUNC.
// This happens during import, where the hidden_fndcl rule has
// used functype directly to parse the function's type.
func funcargs2(t *Type) {
if t.Etype != TFUNC {
Fatalf("funcargs2 %v", t)
......@@ -735,11 +713,9 @@ func funcargs2(t *Type) {
}
}
/*
* finish the body.
* called in auto-declaration context.
* returns in extern-declaration context.
*/
// finish the body.
// called in auto-declaration context.
// returns in extern-declaration context.
func funcbody(n *Node) {
// change the declaration context from auto to extern
if dclcontext != PAUTO {
......@@ -754,9 +730,7 @@ func funcbody(n *Node) {
}
}
/*
* new type being defined with name s.
*/
// new type being defined with name s.
func typedcl0(s *Sym) *Node {
n := newname(s)
n.Op = OTYPE
......@@ -764,21 +738,17 @@ func typedcl0(s *Sym) *Node {
return n
}
/*
* node n, which was returned by typedcl0
* is being declared to have uncompiled type t.
* return the ODCLTYPE node to use.
*/
// node n, which was returned by typedcl0
// is being declared to have uncompiled type t.
// return the ODCLTYPE node to use.
func typedcl1(n *Node, t *Node, local bool) *Node {
n.Name.Param.Ntype = t
n.Local = local
return Nod(ODCLTYPE, n, nil)
}
/*
* structs, functions, and methods.
* they don't belong here, but where do they belong?
*/
// structs, functions, and methods.
// they don't belong here, but where do they belong?
func checkembeddedtype(t *Type) {
if t == nil {
return
......@@ -869,10 +839,8 @@ func checkdupfields(t *Type, what string) {
lineno = int32(lno)
}
/*
* convert a parsed id/type list into
* a type for struct/interface/arglist
*/
// convert a parsed id/type list into
// a type for struct/interface/arglist
func tostruct(l *NodeList) *Type {
t := typ(TSTRUCT)
tostruct0(t, l)
......@@ -915,7 +883,7 @@ func tofunargs(l *NodeList) *Type {
f = structfield(l.N)
f.Funarg = true
// esc.c needs to find f given a PPARAM to add the tag.
// esc.go needs to find f given a PPARAM to add the tag.
if l.N.Left != nil && l.N.Left.Class == PPARAM {
l.N.Left.Name.Param.Field = f
}
......@@ -1075,9 +1043,7 @@ func embedded(s *Sym, pkg *Pkg) *Node {
return n
}
/*
* check that the list of declarations is either all anonymous or all named
*/
// check that the list of declarations is either all anonymous or all named
func findtype(l *NodeList) *Node {
for ; l != nil; l = l.Next {
if l.N.Op == OKEY {
......@@ -1142,7 +1108,7 @@ func checkarglist(all *NodeList, input int) *NodeList {
// declarations, which are parsed by rules that don't
// use checkargs, but can happen for func literals in
// the inline bodies.
// TODO(rsc) this can go when typefmt case TFIELD in exportmode fmt.c prints _ instead of ?
// TODO(rsc) this can go when typefmt case TFIELD in exportmode fmt.go prints _ instead of ?
if importpkg != nil && n.Sym == nil {
n = nil
}
......@@ -1182,12 +1148,9 @@ func fakethis() *Node {
return n
}
/*
* Is this field a method on an interface?
* Those methods have an anonymous
* *struct{} as the receiver.
* (See fakethis above.)
*/
// Is this field a method on an interface?
// Those methods have an anonymous *struct{} as the receiver.
// (See fakethis above.)
func isifacemethod(f *Type) bool {
rcvr := getthisx(f).Type
if rcvr.Sym != nil {
......@@ -1204,10 +1167,7 @@ func isifacemethod(f *Type) bool {
return true
}
/*
* turn a parsed function declaration
* into a type
*/
// turn a parsed function declaration into a type
func functype(this *Node, in *NodeList, out *NodeList) *Type {
t := typ(TFUNC)
functype0(t, this, in, out)
......@@ -1355,10 +1315,8 @@ func methodname1(n *Node, t *Node) *Node {
return n
}
/*
* add a method, declared as a function,
* n is fieldname, pa is base type, t is function type
*/
// add a method, declared as a function,
// n is fieldname, pa is base type, t is function type
func addmethod(sf *Sym, t *Type, local bool, nointerface bool) {
// get field sym
if sf == nil {
......
src/cmd/compile/internal/gc/esc.go
View file @ 6327e8dc
......@@ -856,7 +856,7 @@ func esc(e *EscState, n *Node, up *Node) {
var v *Node
for ll := n.Func.Cvars; ll != nil; ll = ll.Next {
v = ll.N
if v.Op == OXXX { // unnamed out argument; see dcl.c:/^funcargs
if v.Op == OXXX { // unnamed out argument; see dcl.go:/^funcargs
continue
}
a = v.Name.Param.Closure
......
src/cmd/compile/internal/gc/export.go
View file @ 6327e8dc
......@@ -435,13 +435,9 @@ func dumpexport() {
}
}
/*
* import
*/
// import
/*
* return the sym for ss, which should match lexical
*/
// return the sym for ss, which should match lexical
func importsym(s *Sym, op int) *Sym {
if s.Def != nil && int(s.Def.Op) != op {
pkgstr := fmt.Sprintf("during import %q", importpkg.Path)
......@@ -460,9 +456,7 @@ func importsym(s *Sym, op int) *Sym {
return s
}
/*
* return the type pkg.name, forward declaring if needed
*/
// return the type pkg.name, forward declaring if needed
func pkgtype(s *Sym) *Type {
importsym(s, OTYPE)
if s.Def == nil || s.Def.Op != OTYPE {
......
src/cmd/compile/internal/gc/fmt.go
View file @ 6327e8dc
......@@ -47,7 +47,7 @@ import (
// Flags: those of %N
// ',' separate items with ',' instead of ';'
//
// In mparith1.c:
// In mparith2.go and mparith3.go:
// %B Mpint* Big integers
// %F Mpflt* Big floats
//
......@@ -713,7 +713,7 @@ func typefmt(t *Type, flag int) string {
}
} else if fmtmode == FExp {
// TODO(rsc) this breaks on the eliding of unused arguments in the backend
// when this is fixed, the special case in dcl.c checkarglist can go.
// when this is fixed, the special case in dcl.go checkarglist can go.
//if(t->funarg)
// fmtstrcpy(fp, "_ ");
//else
......
src/cmd/compile/internal/gc/gen.go
View file @ 6327e8dc
......@@ -9,10 +9,8 @@ import (
"fmt"
)
/*
* portable half of code generator.
* mainly statements and control flow.
*/
// portable half of code generator.
// mainly statements and control flow.
var labellist *Label
var lastlabel *Label
......@@ -211,18 +209,14 @@ func stmtlabel(n *Node) *Label {
return nil
}
/*
* compile statements
*/
// compile statements
func Genlist(l *NodeList) {
for ; l != nil; l = l.Next {
gen(l.N)
}
}
/*
* generate code to start new proc running call n.
*/
// generate code to start new proc running call n.
func cgen_proc(n *Node, proc int) {
switch n.Left.Op {
default:
......@@ -239,11 +233,9 @@ func cgen_proc(n *Node, proc int) {
}
}
/*
* generate declaration.
* have to allocate heap copy
* for escaped variables.
*/
// generate declaration.
// have to allocate heap copy
// for escaped variables.
func cgen_dcl(n *Node) {
if Debug['g'] != 0 {
Dump("\ncgen-dcl", n)
......@@ -265,9 +257,7 @@ func cgen_dcl(n *Node) {
Cgen_as(n.Name.Heapaddr, prealloc[n])
}
/*
* generate discard of value
*/
// generate discard of value
func cgen_discard(nr *Node) {
if nr == nil {
return
......@@ -322,9 +312,7 @@ func cgen_discard(nr *Node) {
}
}
/*
* clearslim generates code to zero a slim node.
*/
// clearslim generates code to zero a slim node.
func Clearslim(n *Node) {
var z Node
z.Op = OLITERAL
......@@ -367,17 +355,13 @@ func Clearslim(n *Node) {
Cgen(&z, n)
}
/*
* generate:
* res = iface{typ, data}
* n->left is typ
* n->right is data
*/
// generate:
// res = iface{typ, data}
// n->left is typ
// n->right is data
func Cgen_eface(n *Node, res *Node) {
/*
* the right node of an eface may contain function calls that uses res as an argument,
* so it's important that it is done first
*/
// the right node of an eface may contain function calls that uses res as an argument,
// so it's important that it is done first
tmp := temp(Types[Tptr])
Cgen(n.Right, tmp)
......@@ -393,13 +377,11 @@ func Cgen_eface(n *Node, res *Node) {
Cgen(n.Left, &dst)
}
/*
* generate one of:
* res, resok = x.(T)
* res = x.(T) (when resok == nil)
* n.Left is x
* n.Type is T
*/
// generate one of:
// res, resok = x.(T)
// res = x.(T) (when resok == nil)
// n.Left is x
// n.Type is T
func cgen_dottype(n *Node, res, resok *Node, wb bool) {
if Debug_typeassert > 0 {
Warn("type assertion inlined")
......@@ -485,12 +467,10 @@ func cgen_dottype(n *Node, res, resok *Node, wb bool) {
}
}
/*
* generate:
* res, resok = x.(T)
* n.Left is x
* n.Type is T
*/
// generate:
// res, resok = x.(T)
// n.Left is x
// n.Type is T
func Cgen_As2dottype(n, res, resok *Node) {
if Debug_typeassert > 0 {
Warn("type assertion inlined")
......@@ -549,11 +529,9 @@ func Cgen_As2dottype(n, res, resok *Node) {
Patch(q, Pc)
}
/*
* gather series of offsets
* >=0 is direct addressed field
* <0 is pointer to next field (+1)
*/
// gather series of offsets
// >=0 is direct addressed field
// <0 is pointer to next field (+1)
func Dotoffset(n *Node, oary []int64, nn **Node) int {
var i int
......@@ -602,9 +580,7 @@ func Dotoffset(n *Node, oary []int64, nn **Node) int {
return i
}
/*
* make a new off the books
*/
// make a new off the books
func Tempname(nn *Node, t *Type) {
if Curfn == nil {
Fatalf("no curfn for tempname")
......
src/cmd/compile/internal/gc/go.go
View file @ 6327e8dc
......@@ -325,8 +325,8 @@ const (
)
const (
/* types of channel */
/* must match ../../pkg/nreflect/type.go:/Chandir */
// types of channel
// must match ../../pkg/nreflect/type.go:/Chandir
Cxxx = 0
Crecv = 1 << 0
Csend = 1 << 1
......@@ -399,10 +399,8 @@ type Idir struct {
dir string
}
/*
* argument passing to/from
* smagic and umagic
*/
// argument passing to/from
// smagic and umagic
type Magic struct {
W int // input for both - width
S int // output for both - shift
......@@ -418,17 +416,15 @@ type Magic struct {
Ua int // output - adder
}
/*
* note this is the runtime representation
* of the compilers arrays.
*
* typedef struct
* { // must not move anything
* uchar array[8]; // pointer to data
* uchar nel[4]; // number of elements
* uchar cap[4]; // allocated number of elements
* } Array;
*/
// note this is the runtime representation
// of the compilers arrays.
//
// typedef struct
// { // must not move anything
// uchar array[8]; // pointer to data
// uchar nel[4]; // number of elements
// uchar cap[4]; // allocated number of elements
// } Array;
var Array_array int // runtime offsetof(Array,array) - same for String
var Array_nel int // runtime offsetof(Array,nel) - same for String
......@@ -437,16 +433,14 @@ var Array_cap int // runtime offsetof(Array,cap)
var sizeof_Array int // runtime sizeof(Array)
/*
* note this is the runtime representation
* of the compilers strings.
*
* typedef struct
* { // must not move anything
* uchar array[8]; // pointer to data
* uchar nel[4]; // number of elements
* } String;
*/
// note this is the runtime representation
// of the compilers strings.
//
// typedef struct
// { // must not move anything
// uchar array[8]; // pointer to data
// uchar nel[4]; // number of elements
// } String;
var sizeof_String int // runtime sizeof(String)
var dotlist [10]Dlist // size is max depth of embeddeds
......@@ -714,9 +708,7 @@ type Graph struct {
Rpo []*Flow
}
/*
* interface to back end
*/
// interface to back end
const (
// Pseudo-op, like TEXT, GLOBL, TYPE, PCDATA, FUNCDATA.
......
src/cmd/compile/internal/gc/gsubr.go
View file @ 6327e8dc
......@@ -43,9 +43,7 @@ var dfirst *obj.Prog
var dpc *obj.Prog
/*
* Is this node a memory operand?
*/
// Is this node a memory operand?
func Ismem(n *Node) bool {
switch n.Op {
case OITAB,
......@@ -662,11 +660,9 @@ func Anyregalloc() bool {
return n > len(Thearch.ReservedRegs)
}
/*
* allocate register of type t, leave in n.
* if o != N, o may be reusable register.
* caller must Regfree(n).
*/
// allocate register of type t, leave in n.
// if o != N, o may be reusable register.
// caller must Regfree(n).
func Regalloc(n *Node, t *Type, o *Node) {
if t == nil {
Fatalf("regalloc: t nil")
......
src/cmd/compile/internal/gc/init.go
View file @ 6327e8dc
......@@ -17,13 +17,11 @@ package gc
// a->offset += v;
// break;
/*
* 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".
*/
// 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
......@@ -32,24 +30,22 @@ func renameinit() *Sym {
return Lookupf("init.%d", renameinit_initgen)
}
/*
* hand-craft the following initialization code
* var initdone· uint8 (1)
* func init() (2)
* if initdone· != 0 { (3)
* if initdone· == 2 (4)
* return
* throw(); (5)
* }
* initdone· = 1; (6)
* // over all matching imported symbols
* <pkg>.init() (7)
* { <init stmts> } (8)
* init.<n>() // if any (9)
* initdone· = 2; (10)
* return (11)
* }
*/
// hand-craft the following initialization code
// var initdone· uint8 (1)
// func init() (2)
// if initdone· != 0 { (3)
// if initdone· == 2 (4)
// return
// throw(); (5)
// }
// initdone· = 1; (6)
// // over all matching imported symbols
// <pkg>.init() (7)
// { <init stmts> } (8)
// init.<n>() // if any (9)
// initdone· = 2; (10)
// return (11)
// }
func anyinit(n *NodeList) bool {
// are there any interesting init statements
for l := n; l != nil; l = l.Next {
......
src/cmd/compile/internal/gc/lex.go
View file @ 6327e8dc
......@@ -535,7 +535,7 @@ func arsize(b *obj.Biobuf, name string) int {
}
func skiptopkgdef(b *obj.Biobuf) bool {
/* archive header */
// archive header
p := obj.Brdline(b, '\n')
if p == "" {
return false
......@@ -547,7 +547,7 @@ func skiptopkgdef(b *obj.Biobuf) bool {
return false
}
/* symbol table may be first; skip it */
// symbol table may be first; skip it
sz := arsize(b, "__.GOSYMDEF")
if sz >= 0 {
......@@ -556,7 +556,7 @@ func skiptopkgdef(b *obj.Biobuf) bool {
obj.Bseek(b, 8, 0)
}
/* package export block is next */
// package export block is next
sz = arsize(b, "__.PKGDEF")
if sz <= 0 {
......@@ -946,10 +946,10 @@ l0:
goto l0
}
lineno = lexlineno /* start of token */
lineno = lexlineno // start of token
if c >= utf8.RuneSelf {
/* all multibyte runes are alpha */
// all multibyte runes are alpha
cp = &lexbuf
cp.Reset()
......@@ -1073,7 +1073,7 @@ l0:
c1 = '.'
}
/* "..." */
// "..."
case '"':
lexbuf.Reset()
lexbuf.WriteString(`"<string>"`)
......@@ -1094,7 +1094,7 @@ l0:
goto strlit
/* `...` */
// `...`
case '`':
lexbuf.Reset()
lexbuf.WriteString("`<string>`")
......@@ -1120,7 +1120,7 @@ l0:
goto strlit
/* '.' */
// '.'
case '\'':
if escchar('\'', &escflag, &v) {
Yyerror("empty character literal or unescaped ' in character literal")
......@@ -1336,24 +1336,22 @@ l0:
goto asop
}
/*
* clumsy dance:
* to implement rule that disallows
* if T{1}[0] { ... }
* but allows
* if (T{1}[0]) { ... }
* the block bodies for if/for/switch/select
* begin with an LBODY token, not '{'.
*
* when we see the keyword, the next
* non-parenthesized '{' becomes an LBODY.
* loophack is normally false.
* a keyword sets it to true.
* parens push loophack onto a stack and go back to false.
* a '{' with loophack == true becomes LBODY and disables loophack.
*
* i said it was clumsy.
*/
// clumsy dance:
// to implement rule that disallows
// if T{1}[0] { ... }
// but allows
// if (T{1}[0]) { ... }
// the block bodies for if/for/switch/select
// begin with an LBODY token, not '{'.
//
// when we see the keyword, the next
// non-parenthesized '{' becomes an LBODY.
// loophack is normally false.
// a keyword sets it to true.
// parens push loophack onto a stack and go back to false.
// a '{' with loophack == true becomes LBODY and disables loophack.
//
// I said it was clumsy.
case '(', '[':
if loophack || _yylex_lstk != nil {
h = new(Loophack)
......@@ -1426,10 +1424,8 @@ asop:
}
return LASOP
/*
* cp is set to lexbuf and some
* prefix has been stored
*/
// cp is set to lexbuf and some
// prefix has been stored
talph:
for {
if c >= utf8.RuneSelf {
......@@ -1594,12 +1590,10 @@ func more(pp *string) bool {
return p != ""
}
/*
* read and interpret syntax that looks like
* //line parse.y:15
* as a discontinuity in sequential line numbers.
* the next line of input comes from parse.y:15
*/
// read and interpret syntax that looks like
// //line parse.y:15
// as a discontinuity in sequential line numbers.
// the next line of input comes from parse.y:15
func getlinepragma() int {
var cmd, verb, name string
......@@ -2161,7 +2155,7 @@ var syms = []struct {
etype int
op int
}{
/* basic types */
// basic types
{"int8", LNAME, TINT8, OXXX},
{"int16", LNAME, TINT16, OXXX},
{"int32", LNAME, TINT32, OXXX},
......
src/cmd/compile/internal/gc/obj.go
View file @ 6327e8dc
......@@ -10,9 +10,7 @@ import (
"strconv"
)
/*
* architecture-independent object file output
*/
// architecture-independent object file output
const (
ArhdrSize = 60
)
......
src/cmd/compile/internal/gc/order.go
View file @ 6327e8dc
......@@ -396,7 +396,7 @@ func ordercall(n *Node, order *Order) {
// contain m or k. They are usually unnecessary, but in the unnecessary
// cases they are also typically registerizable, so not much harm done.
// And this only applies to the multiple-assignment form.
// We could do a more precise analysis if needed, like in walk.c.
// We could do a more precise analysis if needed, like in walk.go.
//
// Ordermapassign also inserts these temporaries if needed for
// calling writebarrierfat with a pointer to n->right.
......@@ -408,7 +408,7 @@ func ordermapassign(n *Node, order *Order) {
case OAS:
order.out = list(order.out, n)
// We call writebarrierfat only for values > 4 pointers long. See walk.c.
// We call writebarrierfat only for values > 4 pointers long. See walk.go.
if (n.Left.Op == OINDEXMAP || (needwritebarrier(n.Left, n.Right) && n.Left.Type.Width > int64(4*Widthptr))) && !isaddrokay(n.Right) {
m := n.Left
n.Left = ordertemp(m.Type, order, false)
......
src/cmd/compile/internal/gc/popt.go
View file @ 6327e8dc
......@@ -88,7 +88,7 @@ func Noreturn(p *obj.Prog) bool {
// longer and more difficult to follow during debugging.
// Remove them.
/* what instruction does a JMP to p eventually land on? */
// what instruction does a JMP to p eventually land on?
func chasejmp(p *obj.Prog, jmploop *int) *obj.Prog {
n := 0
for p != nil && p.As == obj.AJMP && p.To.Type == obj.TYPE_BRANCH {
......@@ -104,14 +104,12 @@ func chasejmp(p *obj.Prog, jmploop *int) *obj.Prog {
return p
}
/*
* reuse reg pointer for mark/sweep state.
* leave reg==nil at end because alive==nil.
*/
// reuse reg pointer for mark/sweep state.
// leave reg==nil at end because alive==nil.
var alive interface{} = nil
var dead interface{} = 1
/* mark all code reachable from firstp as alive */
// mark all code reachable from firstp as alive
func mark(firstp *obj.Prog) {
for p := firstp; p != nil; p = p.Link {
if p.Opt != dead {
......@@ -335,21 +333,19 @@ func Flowend(graph *Graph) {
}
}
/*
* find looping structure
*
* 1) find reverse postordering
* 2) find approximate dominators,
* the actual dominators if the flow graph is reducible
* otherwise, dominators plus some other non-dominators.
* See Matthew S. Hecht and Jeffrey D. Ullman,
* "Analysis of a Simple Algorithm for Global Data Flow Problems",
* Conf. Record of ACM Symp. on Principles of Prog. Langs, Boston, Massachusetts,
* Oct. 1-3, 1973, pp. 207-217.
* 3) find all nodes with a predecessor dominated by the current node.
* such a node is a loop head.
* recursively, all preds with a greater rpo number are in the loop
*/
// find looping structure
//
// 1) find reverse postordering
// 2) find approximate dominators,
// the actual dominators if the flow graph is reducible
// otherwise, dominators plus some other non-dominators.
// See Matthew S. Hecht and Jeffrey D. Ullman,
// "Analysis of a Simple Algorithm for Global Data Flow Problems",
// Conf. Record of ACM Symp. on Principles of Prog. Langs, Boston, Massachusetts,
// Oct. 1-3, 1973, pp. 207-217.
// 3) find all nodes with a predecessor dominated by the current node.
// such a node is a loop head.
// recursively, all preds with a greater rpo number are in the loop
func postorder(r *Flow, rpo2r []*Flow, n int32) int32 {
r.Rpo = 1
r1 := r.S1
......@@ -903,7 +899,7 @@ func nilopt(firstp *obj.Prog) {
return
}
if Debug_checknil > 1 { /* || strcmp(curfn->nname->sym->name, "f1") == 0 */
if Debug_checknil > 1 { // || strcmp(curfn->nname->sym->name, "f1") == 0
Dumpit("nilopt", g.Start, 0)
}
......
src/cmd/compile/internal/gc/range.go
View file @ 6327e8dc
......@@ -6,9 +6,7 @@ package gc
import "cmd/internal/obj"
/*
* range
*/
// range
func typecheckrange(n *Node) {
var toomany int
var why string
......
src/cmd/compile/internal/gc/reflect.go
View file @ 6327e8dc
......@@ -12,9 +12,7 @@ import (
"sort"
)
/*
* runtime interface and reflection data structures
*/
// runtime interface and reflection data structures
var signatlist *NodeList
// byMethodNameAndPackagePath sorts method signatures by name, then package path.
......@@ -237,10 +235,8 @@ func hiter(t *Type) *Type {
return i
}
/*
* f is method type, with receiver.
* return function type, receiver as first argument (or not).
*/
// f is method type, with receiver.
// return function type, receiver as first argument (or not).
func methodfunc(f *Type, receiver *Type) *Type {
var in *NodeList
if receiver != nil {
......@@ -477,10 +473,8 @@ func dgopkgpath(s *Sym, ot int, pkg *Pkg) int {
return dsymptr(s, ot, pkg.Pathsym, 0)
}
/*
* uncommonType
* ../../runtime/type.go:/uncommonType
*/
// uncommonType
// ../../runtime/type.go:/uncommonType
func dextratype(sym *Sym, off int, t *Type, ptroff int) int {
m := methods(t)
if t.Sym == nil && len(m) == 0 {
......@@ -686,10 +680,8 @@ func typeptrdata(t *Type) int64 {
}
}
/*
* commonType
* ../../runtime/type.go:/commonType
*/
// commonType
// ../../runtime/type.go:/commonType
var dcommontype_algarray *Sym
......
src/cmd/compile/internal/gc/reg.go
View file @ 6327e8dc
......@@ -218,10 +218,8 @@ func walkvardef(n *Node, f *Flow, active int) {
}
}
/*
* add mov b,rn
* just after r
*/
// add mov b,rn
// just after r
func addmove(r *Flow, bn int, rn int, f int) {
p1 := Ctxt.NewProg()
Clearp(p1)
......@@ -282,9 +280,7 @@ func overlap_reg(o1 int64, w1 int, o2 int64, w2 int) bool {
}
func mkvar(f *Flow, a *obj.Addr) Bits {
/*
* mark registers used
*/
// mark registers used
if a.Type == obj.TYPE_NONE {
return zbits
}
......@@ -460,7 +456,7 @@ func mkvar(f *Flow, a *obj.Addr) Bits {
}
// Treat values with their address taken as live at calls,
// because the garbage collector's liveness analysis in ../gc/plive.c does.
// because the garbage collector's liveness analysis in plive.go does.
// These must be consistent or else we will elide stores and the garbage
// collector will see uninitialized data.
// The typical case where our own analysis is out of sync is when the
......@@ -473,7 +469,7 @@ func mkvar(f *Flow, a *obj.Addr) Bits {
// sets addrtaken, even though it ends up not being actually shared.
// If we were better about _ elision, _ = &x would suffice too.
// The broader := in a closure problem is mentioned in a comment in
// closure.c:/^typecheckclosure and dcl.c:/^oldname.
// closure.go:/^typecheckclosure and dcl.go:/^oldname.
if node.Addrtaken {
v.addr = 1
}
......@@ -1036,11 +1032,9 @@ func Dumpit(str string, r0 *Flow, isreg int) {
func regopt(firstp *obj.Prog) {
mergetemp(firstp)
/*
* control flow is more complicated in generated go code
* than in generated c code. define pseudo-variables for
* registers, so we have complete register usage information.
*/
// control flow is more complicated in generated go code
// than in generated c code. define pseudo-variables for
// registers, so we have complete register usage information.
var nreg int
regnames := Thearch.Regnames(&nreg)
......@@ -1063,12 +1057,10 @@ func regopt(firstp *obj.Prog) {
ivar = zbits
ovar = zbits
/*
* pass 1
* build aux data structure
* allocate pcs
* find use and set of variables
*/
// pass 1
// build aux data structure
// allocate pcs
// find use and set of variables
g := Flowstart(firstp, func() interface{} { return new(Reg) })
if g == nil {
for i := 0; i < nvar; i++ {
......@@ -1159,23 +1151,19 @@ func regopt(firstp *obj.Prog) {
Dumpit("pass1", firstf, 1)
}
/*
* pass 2
* find looping structure
*/
// pass 2
// find looping structure
flowrpo(g)
if Debug['R'] != 0 && Debug['v'] != 0 {
Dumpit("pass2", firstf, 1)
}
/*
* pass 2.5
* iterate propagating fat vardef covering forward
* r->act records vars with a VARDEF since the last CALL.
* (r->act will be reused in pass 5 for something else,
* but we'll be done with it by then.)
*/
// pass 2.5
// iterate propagating fat vardef covering forward
// r->act records vars with a VARDEF since the last CALL.
// (r->act will be reused in pass 5 for something else,
// but we'll be done with it by then.)
active := 0
for f := firstf; f != nil; f = f.Link {
......@@ -1192,11 +1180,9 @@ func regopt(firstp *obj.Prog) {
}
}
/*
* pass 3
* iterate propagating usage
* back until flow graph is complete
*/
// pass 3
// iterate propagating usage
// back until flow graph is complete
var f1 *Flow
var i int
var f *Flow
......@@ -1212,7 +1198,7 @@ loop1:
}
}
/* pick up unreachable code */
// pick up unreachable code
loop11:
i = 0
......@@ -1235,11 +1221,9 @@ loop11:
Dumpit("pass3", firstf, 1)
}
/*
* pass 4
* iterate propagating register/variable synchrony
* forward until graph is complete
*/
// pass 4
// iterate propagating register/variable synchrony
// forward until graph is complete
loop2:
change = 0
......@@ -1255,10 +1239,8 @@ loop2:
Dumpit("pass4", firstf, 1)
}
/*
* pass 4.5
* move register pseudo-variables into regu.
*/
// pass 4.5
// move register pseudo-variables into regu.
mask := uint64((1 << uint(nreg)) - 1)
for f := firstf; f != nil; f = f.Link {
r := f.Data.(*Reg)
......@@ -1278,11 +1260,9 @@ loop2:
Dumpit("pass4.5", firstf, 1)
}
/*
* pass 5
* isolate regions
* calculate costs (paint1)
*/
// pass 5
// isolate regions
// calculate costs (paint1)
var bit Bits
if f := firstf; f != nil {
r := f.Data.(*Reg)
......@@ -1358,11 +1338,9 @@ loop2:
Dumpit("pass5", firstf, 1)
}
/*
* pass 6
* determine used registers (paint2)
* replace code (paint3)
*/
// pass 6
// determine used registers (paint2)
// replace code (paint3)
if Debug['R'] != 0 && Debug['v'] != 0 {
fmt.Printf("\nregisterizing\n")
}
......@@ -1386,9 +1364,7 @@ loop2:
}
}
/*
* free aux structures. peep allocates new ones.
*/
// free aux structures. peep allocates new ones.
for i := 0; i < nvar; i++ {
vars[i].node.SetOpt(nil)
}
......@@ -1404,17 +1380,13 @@ loop2:
firstf = nil
}
/*
* pass 7
* peep-hole on basic block
*/
// pass 7
// peep-hole on basic block
if Debug['R'] == 0 || Debug['P'] != 0 {
Thearch.Peep(firstp)
}
/*
* eliminate nops
*/
// eliminate nops
for p := firstp; p != nil; p = p.Link {
for p.Link != nil && p.Link.As == obj.ANOP {
p.Link = p.Link.Link
......
src/cmd/compile/internal/gc/select.go
View file @ 6327e8dc
......@@ -4,9 +4,7 @@
package gc
/*
* select
*/
// select
func typecheckselect(sel *Node) {
var ncase *Node
var n *Node
......@@ -109,7 +107,7 @@ func walkselect(sel *Node) {
}
// optimization: one-case select: single op.
// TODO(rsc): Reenable optimization once order.c can handle it.
// TODO(rsc): Reenable optimization once order.go can handle it.
// golang.org/issue/7672.
if i == 1 {
cas := sel.List.N
......
src/cmd/compile/internal/gc/sinit.go
View file @ 6327e8dc
......@@ -9,9 +9,7 @@ import (
"fmt"
)
/*
* static initialization
*/
// static initialization
const (
InitNotStarted = 0
InitDone = 1
......@@ -248,10 +246,8 @@ func initfix(l *NodeList) *NodeList {
return lout
}
/*
* compilation of top-level (static) assignments
* into DATA statements if at all possible.
*/
// compilation of top-level (static) assignments
// into DATA statements if at all possible.
func staticinit(n *Node, out **NodeList) bool {
if n.Op != ONAME || n.Class != PEXTERN || n.Name.Defn == nil || n.Name.Defn.Op != OAS {
Fatalf("staticinit")
......@@ -489,13 +485,11 @@ func staticassign(l *Node, r *Node, out **NodeList) bool {
return false
}
/*
* from here down is the walk analysis
* of composite literals.
* most of the work is to generate
* data statements for the constant
* part of the composite literal.
*/
// from here down is the walk analysis
// of composite literals.
// most of the work is to generate
// data statements for the constant
// part of the composite literal.
func staticname(t *Type, ctxt int) *Node {
n := newname(Lookupf("statictmp_%.4d", statuniqgen))
statuniqgen++
......@@ -765,7 +759,7 @@ func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) {
// set auto to point at new temp or heap (3 assign)
var a *Node
if x := prealloc[n]; x != nil {
// temp allocated during order.c for dddarg
// temp allocated during order.go for dddarg
x.Type = t
if vstat == nil {
......
src/cmd/compile/internal/gc/subr.go
View file @ 6327e8dc
......@@ -846,10 +846,8 @@ func isideal(t *Type) bool {
return false
}
/*
* given receiver of type t (t == r or t == *r)
* return type to hang methods off (r).
*/
// given receiver of type t (t == r or t == *r)
// return type to hang methods off (r).
func methtype(t *Type, mustname int) *Type {
if t == nil {
return nil
......@@ -1383,9 +1381,7 @@ func substAny(tp **Type, types *[]*Type) {
}
}
/*
* Is this a 64-bit type?
*/
// Is this a 64-bit type?
func Is64(t *Type) bool {
if t == nil {
return false
......@@ -1398,9 +1394,7 @@ func Is64(t *Type) bool {
return false
}
/*
* Is a conversion between t1 and t2 a no-op?
*/
// Is a conversion between t1 and t2 a no-op?
func Noconv(t1 *Type, t2 *Type) bool {
e1 := int(Simtype[t1.Etype])
e2 := int(Simtype[t2.Etype])
......@@ -1501,18 +1495,16 @@ func syslook(name string, copy int) *Node {
return n
}
/*
* compute a hash value for type t.
* if t is a method type, ignore the receiver
* so that the hash can be used in interface checks.
* %T already contains
* all the necessary logic to generate a representation
* of the type that completely describes it.
* using smprint here avoids duplicating that code.
* using md5 here is overkill, but i got tired of
* accidental collisions making the runtime think
* two types are equal when they really aren't.
*/
// compute a hash value for type t.
// if t is a method type, ignore the receiver
// so that the hash can be used in interface checks.
// %T already contains
// all the necessary logic to generate a representation
// of the type that completely describes it.
// using smprint here avoids duplicating that code.
// using md5 here is overkill, but i got tired of
// accidental collisions making the runtime think
// two types are equal when they really aren't.
func typehash(t *Type) uint32 {
var p string
......@@ -1613,12 +1605,10 @@ func printframenode(n *Node) {
}
}
/*
* calculate sethi/ullman number
* roughly how many registers needed to
* compile a node. used to compile the
* hardest side first to minimize registers.
*/
// calculate sethi/ullman number
// roughly how many registers needed to
// compile a node. used to compile the
// hardest side first to minimize registers.
func ullmancalc(n *Node) {
if n == nil {
return
......@@ -1695,9 +1685,7 @@ func badtype(o int, tl *Type, tr *Type) {
Yyerror("illegal types for operand: %v%s", Oconv(int(o), 0), s)
}
/*
* iterator to walk a structure declaration
*/
// iterator to walk a structure declaration
func Structfirst(s *Iter, nn **Type) *Type {
var t *Type
......@@ -1749,9 +1737,7 @@ func structnext(s *Iter) *Type {
return t
}
/*
* iterator to this and inargs in a function
*/
// iterator to this and inargs in a function
func funcfirst(s *Iter, t *Type) *Type {
var fp *Type
......@@ -1863,10 +1849,8 @@ func Brrev(a int) int {
return a
}
/*
* return side effect-free n, appending side effects to init.
* result is assignable if n is.
*/
// return side effect-free n, appending side effects to init.
// result is assignable if n is.
func safeexpr(n *Node, init **NodeList) *Node {
if n == nil {
return nil
......@@ -1935,10 +1919,8 @@ func copyexpr(n *Node, t *Type, init **NodeList) *Node {
return l
}
/*
* return side-effect free and cheap n, appending side effects to init.
* result may not be assignable.
*/
// return side-effect free and cheap n, appending side effects to init.
// result may not be assignable.
func cheapexpr(n *Node, init **NodeList) *Node {
switch n.Op {
case ONAME, OLITERAL:
......@@ -1963,14 +1945,10 @@ func Setmaxarg(t *Type, extra int32) {
}
}
/*
* unicode-aware case-insensitive strcmp
*/
// unicode-aware case-insensitive strcmp
/*
* code to resolve elided DOTs
* in embedded types
*/
// code to resolve elided DOTs
// in embedded types
// search depth 0 --
// return count of fields+methods
......@@ -2103,16 +2081,14 @@ func adddot(n *Node) *Node {
return n
}
/*
* code to help generate trampoline
* functions for methods on embedded
* subtypes.
* these are approx the same as
* the corresponding adddot routines
* except that they expect to be called
* with unique tasks and they return
* the actual methods.
*/
// code to help generate trampoline
// functions for methods on embedded
// subtypes.
// these are approx the same as
// the corresponding adddot routines
// except that they expect to be called
// with unique tasks and they return
// the actual methods.
type Symlink struct {
field *Type
link *Symlink
......@@ -2260,9 +2236,7 @@ func expandmeth(t *Type) {
}
}
/*
* Given funarg struct list, return list of ODCLFIELD Node fn args.
*/
// Given funarg struct list, return list of ODCLFIELD Node fn args.
func structargs(tl **Type, mustname int) *NodeList {
var savet Iter
var a *Node
......@@ -2293,29 +2267,27 @@ func structargs(tl **Type, mustname int) *NodeList {
return args
}
/*
* Generate a wrapper function to convert from
* a receiver of type T to a receiver of type U.
* That is,
*
* func (t T) M() {
* ...
* }
*
* already exists; this function generates
*
* func (u U) M() {
* u.M()
* }
*
* where the types T and U are such that u.M() is valid
* and calls the T.M method.
* The resulting function is for use in method tables.
*
* rcvr - U
* method - M func (t T)(), a TFIELD type struct
* newnam - the eventual mangled name of this function
*/
// Generate a wrapper function to convert from
// a receiver of type T to a receiver of type U.
// That is,
//
// func (t T) M() {
// ...
// }
//
// already exists; this function generates
//
// func (u U) M() {
// u.M()
// }
//
// where the types T and U are such that u.M() is valid
// and calls the T.M method.
// The resulting function is for use in method tables.
//
// rcvr - U
// method - M func (t T)(), a TFIELD type struct
// newnam - the eventual mangled name of this function
var genwrapper_linehistdone int = 0
......@@ -2511,9 +2483,7 @@ func hashfor(t *Type) *Node {
return n
}
/*
* Generate a helper function to compute the hash of a value of type t.
*/
// Generate a helper function to compute the hash of a value of type t.
func genhash(sym *Sym, t *Type) {
if Debug['r'] != 0 {
fmt.Printf("genhash %v %v\n", sym, t)
......@@ -2748,9 +2718,7 @@ func eqmem(p *Node, q *Node, field *Node, size int64) *Node {
return nif
}
/*
* Generate a helper function to check equality of two values of type t.
*/
// Generate a helper function to check equality of two values of type t.
func geneq(sym *Sym, t *Type) {
if Debug['r'] != 0 {
fmt.Printf("geneq %v %v\n", sym, t)
......@@ -3020,11 +2988,9 @@ func implements(t *Type, iface *Type, m **Type, samename **Type, ptr *int) bool
return true
}
/*
* even simpler simtype; get rid of ptr, bool.
* assuming that the front end has rejected
* all the invalid conversions (like ptr -> bool)
*/
// even simpler simtype; get rid of ptr, bool.
// assuming that the front end has rejected
// all the invalid conversions (like ptr -> bool)
func Simsimtype(t *Type) int {
if t == nil {
return 0
......@@ -3062,9 +3028,7 @@ func liststmt(l *NodeList) *Node {
return n
}
/*
* return nelem of list
*/
// return nelem of list
func structcount(t *Type) int {
var s Iter
......@@ -3075,11 +3039,9 @@ func structcount(t *Type) int {
return v
}
/*
* return power of 2 of the constant
* operand. -1 if it is not a power of 2.
* 1000+ if it is a -(power of 2)
*/
// return power of 2 of the constant
// operand. -1 if it is not a power of 2.
// 1000+ if it is a -(power of 2)
func powtwo(n *Node) int {
if n == nil || n.Op != OLITERAL || n.Type == nil {
return -1
......@@ -3113,12 +3075,10 @@ func powtwo(n *Node) int {
return -1
}
/*
* return the unsigned type for
* a signed integer type.
* returns T if input is not a
* signed integer type.
*/
// return the unsigned type for
// a signed integer type.
// returns T if input is not a
// signed integer type.
func tounsigned(t *Type) *Type {
// this is types[et+1], but not sure
// that this relation is immutable
......@@ -3146,10 +3106,8 @@ func tounsigned(t *Type) *Type {
return t
}
/*
* magic number for signed division
* see hacker's delight chapter 10
*/
// magic number for signed division
// see hacker's delight chapter 10
func Smagic(m *Magic) {
var mask uint64
......@@ -3243,10 +3201,8 @@ func Smagic(m *Magic) {
m.S = p - m.W
}
/*
* magic number for unsigned division
* see hacker's delight chapter 10
*/
// magic number for unsigned division
// see hacker's delight chapter 10
func Umagic(m *Magic) {
var mask uint64
......@@ -3353,15 +3309,13 @@ func ngotype(n *Node) *Sym {
return nil
}
/*
* Convert raw string to the prefix that will be used in the symbol
* table. All control characters, space, '%' and '"', as well as
* non-7-bit clean bytes turn into %xx. The period needs escaping
* only in the last segment of the path, and it makes for happier
* users if we escape that as little as possible.
*
* If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
*/
// Convert raw string to the prefix that will be used in the symbol
// table. All control characters, space, '%' and '"', as well as
// non-7-bit clean bytes turn into %xx. The period needs escaping
// only in the last segment of the path, and it makes for happier
// users if we escape that as little as possible.
//
// If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
func pathtoprefix(s string) string {
slash := strings.LastIndex(s, "/")
for i := 0; i < len(s); i++ {
......@@ -3479,10 +3433,8 @@ func checknil(x *Node, init **NodeList) {
*init = list(*init, n)
}
/*
* Can this type be stored directly in an interface word?
* Yes, if the representation is a single pointer.
*/
// Can this type be stored directly in an interface word?
// Yes, if the representation is a single pointer.
func isdirectiface(t *Type) bool {
switch t.Etype {
case TPTR32,
......
src/cmd/compile/internal/gc/typecheck.go
View file @ 6327e8dc
......@@ -11,18 +11,14 @@ import (
"strings"
)
/*
* type check the whole tree of an expression.
* calculates expression types.
* evaluates compile time constants.
* marks variables that escape the local frame.
* rewrites n->op to be more specific in some cases.
*/
// type check the whole tree of an expression.
// calculates expression types.
// evaluates compile time constants.
// marks variables that escape the local frame.
// rewrites n->op to be more specific in some cases.
var typecheckdefstack []*Node
/*
* resolve ONONAME to definition, if any.
*/
// resolve ONONAME to definition, if any.
func resolve(n *Node) *Node {
if n != nil && n.Op == ONONAME && n.Sym != nil {
r := n.Sym.Def
......@@ -194,9 +190,7 @@ func typecheck(np **Node, top int) *Node {
return n
}
/*
* does n contain a call or receive operation?
*/
// does n contain a call or receive operation?
func callrecv(n *Node) bool {
if n == nil {
return false
......@@ -275,9 +269,7 @@ OpSwitch:
Fatalf("typecheck %v", Oconv(int(n.Op), 0))
/*
* names
*/
// names
case OLITERAL:
ok |= Erv
......@@ -327,9 +319,7 @@ OpSwitch:
case ODDD:
break
/*
* types (OIND is with exprs)
*/
// types (OIND is with exprs)
case OTYPE:
ok |= Etype
......@@ -454,9 +444,7 @@ OpSwitch:
return
}
/*
* type or expr
*/
// type or expr
case OIND:
ntop := Erv | Etype
......@@ -492,9 +480,7 @@ OpSwitch:
n.Type = t.Type
break OpSwitch
/*
* arithmetic exprs
*/
// arithmetic exprs
case OASOP,
OADD,
OAND,
......@@ -778,9 +764,7 @@ OpSwitch:
n.Type = t
break OpSwitch
/*
* exprs
*/
// exprs
case OADDR:
ok |= Erv
......@@ -1247,9 +1231,7 @@ OpSwitch:
}
break OpSwitch
/*
* call and call like
*/
// call and call like
case OCALL:
l := n.Left
......@@ -2024,9 +2006,7 @@ OpSwitch:
typecheck(&n.Left, Erv)
break OpSwitch
/*
* statements
*/
// statements
case OAS:
ok |= Etop
......@@ -2616,9 +2596,7 @@ func downcount(t *Type) int {
return n
}
/*
* typecheck assignment: type list = expression list
*/
// typecheck assignment: type list = expression list
func typecheckaste(op int, call *Node, isddd bool, tstruct *Type, nl *NodeList, desc func() string) {
var t *Type
var n *Node
......@@ -2795,9 +2773,7 @@ toomany:
goto out
}
/*
* type check composite
*/
// type check composite
func fielddup(n *Node, hash map[string]bool) {
if n.Op != ONAME {
Fatalf("fielddup: not ONAME")
......@@ -2944,7 +2920,7 @@ func typecheckcomplit(np **Node) {
*norig = *n
setlineno(n.Right)
l := typecheck(&n.Right, Etype|Ecomplit) /* sic */
l := typecheck(&n.Right, Etype|Ecomplit) // sic
t := l.Type
if t == nil {
n.Type = nil
......@@ -3180,9 +3156,7 @@ func typecheckcomplit(np **Node) {
return
}
/*
* lvalue etc
*/
// lvalue etc
func islvalue(n *Node) bool {
switch n.Op {
case OINDEX:
......@@ -3281,11 +3255,9 @@ func samesafeexpr(l *Node, r *Node) bool {
return false
}
/*
* type check assignment.
* if this assignment is the definition of a var on the left side,
* fill in the var's type.
*/
// type check assignment.
// if this assignment is the definition of a var on the left side,
// fill in the var's type.
func typecheckas(n *Node) {
// delicate little dance.
// the definition of n may refer to this assignment
......@@ -3454,9 +3426,7 @@ out:
}
}
/*
* type check function definition
*/
// type check function definition
func typecheckfunc(n *Node) {
typecheck(&n.Func.Nname, Erv|Easgn)
t := n.Func.Nname.Type
......
src/cmd/compile/internal/gc/unsafe.go
View file @ 6327e8dc
......@@ -6,13 +6,11 @@ package gc
import "cmd/internal/obj"
/*
* look for
* unsafe.Sizeof
* unsafe.Offsetof
* unsafe.Alignof
* rewrite with a constant
*/
// look for
// unsafe.Sizeof
// unsafe.Offsetof
// unsafe.Alignof
// rewrite with a constant
func unsafenmagic(nn *Node) *Node {
fn := nn.Left
args := nn.List
......
src/cmd/compile/internal/gc/walk.go
View file @ 6327e8dc
......@@ -366,13 +366,11 @@ func isSmallMakeSlice(n *Node) bool {
return Smallintconst(l) && Smallintconst(r) && (t.Type.Width == 0 || Mpgetfix(r.Val().U.(*Mpint)) < (1<<16)/t.Type.Width)
}
/*
* walk the whole tree of the body of an
* expression or simple statement.
* the types expressions are calculated.
* compile-time constants are evaluated.
* complex side effects like statements are appended to init
*/
// walk the whole tree of the body of an
// expression or simple statement.
// the types expressions are calculated.
// compile-time constants are evaluated.
// complex side effects like statements are appended to init
func walkexprlist(l *NodeList, init **NodeList) {
for ; l != nil; l = l.Next {
walkexpr(&l.N, init)
......@@ -1015,16 +1013,15 @@ func walkexpr(np **Node, init **NodeList) {
ll = list(ll, l)
if isdirectiface(n.Left.Type) {
/* For pointer types, we can make a special form of optimization
*
* These statements are put onto the expression init list:
* Itab *tab = atomicloadtype(&cache);
* if(tab == nil)
* tab = typ2Itab(type, itype, &cache);
*
* The CONVIFACE expression is replaced with this:
* OEFACE{tab, ptr};
*/
// For pointer types, we can make a special form of optimization
//
// These statements are put onto the expression init list:
// Itab *tab = atomicloadtype(&cache);
// if(tab == nil)
// tab = typ2Itab(type, itype, &cache);
//
// The CONVIFACE expression is replaced with this:
// OEFACE{tab, ptr};
l := temp(Ptrto(Types[TUINT8]))
n1 := Nod(OAS, l, sym.Def)
......@@ -1140,9 +1137,7 @@ func walkexpr(np **Node, init **NodeList) {
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
/*
* rewrite complex div into function call.
*/
// rewrite complex div into function call.
et := int(n.Left.Type.Etype)
if Iscomplex[et] && n.Op == ODIV {
......@@ -1160,10 +1155,8 @@ func walkexpr(np **Node, init **NodeList) {
// Try rewriting as shifts or magic multiplies.
walkdiv(&n, init)
/*
* rewrite 64-bit div and mod into function calls
* on 32-bit architectures.
*/
// rewrite 64-bit div and mod into function calls
// on 32-bit architectures.
switch n.Op {
case OMOD, ODIV:
if Widthreg >= 8 || (et != TUINT64 && et != TINT64) {
......@@ -1683,11 +1676,9 @@ func ascompatee1(op int, l *Node, r *Node, init **NodeList) *Node {
}
func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
/*
* check assign expression list to
* a expression list. called in
* expr-list = expr-list
*/
// check assign expression list to
// a expression list. called in
// expr-list = expr-list
// ensure order of evaluation for function calls
for ll := nl; ll != nil; ll = ll.Next {
......@@ -1715,12 +1706,10 @@ func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
return nn
}
/*
* l is an lv and rt is the type of an rv
* return 1 if this implies a function call
* evaluating the lv or a function call
* in the conversion of the types
*/
// l is an lv and rt is the type of an rv
// return 1 if this implies a function call
// evaluating the lv or a function call
// in the conversion of the types
func fncall(l *Node, rt *Type) bool {
if l.Ullman >= UINF || l.Op == OINDEXMAP {
return true
......@@ -1742,11 +1731,9 @@ func ascompatet(op int, nl *NodeList, nr **Type, fp int, init **NodeList) *NodeL
var ll *NodeList
var saver Iter
/*
* check assign type list to
* a expression list. called in
* expr-list = func()
*/
// check assign type list to
// a expression list. called in
// expr-list = func()
r := Structfirst(&saver, nr)
var nn *NodeList
......@@ -1796,9 +1783,7 @@ func ascompatet(op int, nl *NodeList, nr **Type, fp int, init **NodeList) *NodeL
return concat(nn, mm)
}
/*
* package all the arguments that match a ... T parameter into a []T.
*/
// package all the arguments that match a ... T parameter into a []T.
func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList, ddd *Node) *NodeList {
esc := uint16(EscUnknown)
if ddd != nil {
......@@ -1832,9 +1817,7 @@ func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList
return nn
}
/*
* helpers for shape errors
*/
// helpers for shape errors
func dumptypes(nl **Type, what string) string {
var savel Iter
......@@ -1878,12 +1861,10 @@ func dumpnodetypes(l *NodeList, what string) string {
return fmt_
}
/*
* check assign expression list to
* a type list. called in
* return expr-list
* func(expr-list)
*/
// check assign expression list to
// a type list. called in
// return expr-list
// func(expr-list)
func ascompatte(op int, call *Node, isddd bool, nl **Type, lr *NodeList, fp int, init **NodeList) *NodeList {
var savel Iter
......@@ -2286,14 +2267,12 @@ out:
return n
}
/*
* from ascompat[te]
* evaluating actual function arguments.
* f(a,b)
* if there is exactly one function expr,
* then it is done first. otherwise must
* make temp variables
*/
// from ascompat[te]
// evaluating actual function arguments.
// f(a,b)
// if there is exactly one function expr,
// then it is done first. otherwise must
// make temp variables
func reorder1(all *NodeList) *NodeList {
var n *Node
......@@ -2350,14 +2329,12 @@ func reorder1(all *NodeList) *NodeList {
return concat(g, r)
}
/*
* from ascompat[ee]
* a,b = c,d
* simultaneous assignment. there cannot
* be later use of an earlier lvalue.
*
* function calls have been removed.
*/
// from ascompat[ee]
// a,b = c,d
// simultaneous assignment. there cannot
// be later use of an earlier lvalue.
//
// function calls have been removed.
func reorder3(all *NodeList) *NodeList {
var l *Node
......@@ -2413,12 +2390,10 @@ func reorder3(all *NodeList) *NodeList {
return concat(early, all)
}
/*
* if the evaluation of *np would be affected by the
* assignments in all up to but not including stop,
* copy into a temporary during *early and
* replace *np with that temp.
*/
// if the evaluation of *np would be affected by the
// assignments in all up to but not including stop,
// copy into a temporary during *early and
// replace *np with that temp.
func reorder3save(np **Node, all *NodeList, stop *NodeList, early **NodeList) {
n := *np
if !aliased(n, all, stop) {
......@@ -2432,10 +2407,8 @@ func reorder3save(np **Node, all *NodeList, stop *NodeList, early **NodeList) {
*np = q.Left
}
/*
* what's the outer value that a write to n affects?
* outer value means containing struct or array.
*/
// what's the outer value that a write to n affects?
// outer value means containing struct or array.
func outervalue(n *Node) *Node {
for {
if n.Op == OXDOT {
......@@ -2457,10 +2430,8 @@ func outervalue(n *Node) *Node {
return n
}
/*
* Is it possible that the computation of n might be
* affected by writes in as up to but not including stop?
*/
// Is it possible that the computation of n might be
// affected by writes in as up to but not including stop?
func aliased(n *Node, all *NodeList, stop *NodeList) bool {
if n == nil {
return false
......@@ -2521,11 +2492,9 @@ func aliased(n *Node, all *NodeList, stop *NodeList) bool {
return true
}
/*
* does the evaluation of n only refer to variables
* whose addresses have not been taken?
* (and no other memory)
*/
// does the evaluation of n only refer to variables
// whose addresses have not been taken?
// (and no other memory)
func varexpr(n *Node) bool {
if n == nil {
return true
......@@ -2574,9 +2543,7 @@ func varexpr(n *Node) bool {
return false
}
/*
* is the name l mentioned in r?
*/
// is the name l mentioned in r?
func vmatch2(l *Node, r *Node) bool {
if r == nil {
return false
......@@ -2604,14 +2571,10 @@ func vmatch2(l *Node, r *Node) bool {
return false
}
/*
* is any name mentioned in l also mentioned in r?
* called by sinit.go
*/
// is any name mentioned in l also mentioned in r?
// called by sinit.go
func vmatch1(l *Node, r *Node) bool {
/*
* isolate all left sides
*/
// isolate all left sides
if l == nil || r == nil {
return false
}
......@@ -2649,11 +2612,9 @@ func vmatch1(l *Node, r *Node) bool {
return false
}
/*
* walk through argin parameters.
* generate and return code to allocate
* copies of escaped parameters to the heap.
*/
// walk through argin parameters.
// generate and return code to allocate
// copies of escaped parameters to the heap.
func paramstoheap(argin **Type, out int) *NodeList {
var savet Iter
var v *Node
......@@ -2699,9 +2660,7 @@ func paramstoheap(argin **Type, out int) *NodeList {
return nn
}
/*
* walk through argout parameters copying back to stack
*/
// walk through argout parameters copying back to stack
func returnsfromheap(argin **Type) *NodeList {
var savet Iter
var v *Node
......@@ -2718,11 +2677,9 @@ func returnsfromheap(argin **Type) *NodeList {
return nn
}
/*
* take care of migrating any function in/out args
* between the stack and the heap. adds code to
* curfn's before and after lists.
*/
// take care of migrating any function in/out args
// between the stack and the heap. adds code to
// curfn's before and after lists.
func heapmoves() {
lno := lineno
lineno = Curfn.Lineno
......@@ -3455,9 +3412,7 @@ func walkrotate(np **Node) {
return
}
/*
* walkmul rewrites integer multiplication by powers of two as shifts.
*/
// walkmul rewrites integer multiplication by powers of two as shifts.
func walkmul(np **Node, init **NodeList) {
n := *np
if !Isint[n.Type.Etype] {
......@@ -3526,10 +3481,8 @@ ret:
*np = n
}
/*
* walkdiv rewrites division by a constant as less expensive
* operations.
*/
// walkdiv rewrites division by a constant as less expensive
// operations.
func walkdiv(np **Node, init **NodeList) {
// if >= 0, nr is 1<<pow // 1 if nr is negative.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7