goarch=$(go env GOARCH)
goroot=$(go env GOROOT)
if [ ! -d "$goroot" ]; then
- echo 'misc/cgo/testcshared/test.bash cannnot find GOROOT' 1>&2
+ echo 'misc/cgo/testcshared/test.bash cannot find GOROOT' 1>&2
echo '$GOROOT:' "$GOROOT" 1>&2
echo 'go env GOROOT:' "$goroot" 1>&2
exit 1
// If we make an ABI-breaking change to dep and rebuild libp.so but not exe,
// exe will abort with a complaint on startup.
// This assumes adding an exported function breaks ABI, which is not true in
- // some senses but suffices for the narrow definition of ABI compatiblity the
+ // some senses but suffices for the narrow definition of ABI compatibility the
// toolchain uses today.
resetFileStamps()
appendFile("src/dep/dep.go", "func ABIBreak() {}\n")
return
}
- f := true // gen thru register
+ f := true // gen through register
switch n.Op {
case OLITERAL:
if Smallintconst(n) {
"strings"
)
-// IntLiteral returns the Node's literal value as an interger.
+// IntLiteral returns the Node's literal value as an integer.
func (n *Node) IntLiteral() (x int64, ok bool) {
switch {
case n == nil:
}
panic(fmt.Sprintf("can't find field in expr %s\n", n))
- // TODO: keep the result of this fucntion somewhere in the ODOT Node
+ // TODO: keep the result of this function somewhere in the ODOT Node
// so we don't have to recompute it each time we need it.
}
}
stat = append(stat, n.Nbody.Slice()...)
- // botch - shouldn't fall thru declaration
+ // botch - shouldn't fall through declaration
last := stat[len(stat)-1]
if last.Xoffset == n.Xoffset && last.Op == OXFALL {
if typeswvar != nil {
// special case --
// only if we are assigning a single ddd
// argument to a ddd parameter then it is
- // passed thru unencapsulated
+ // passed through unencapsulated
if r != nil && len(lr) <= 1 && isddd && Eqtype(l.Type, r.Type) {
a := Nod(OAS, nodarg(l, fp), r)
a = convas(a, init)
idom[v] = fromID[bucket[0]]
}
- // Step 4. Explictly define the immediate dominator of each vertex,
+ // Step 4. Explicitly define the immediate dominator of each vertex,
// carrying out the computation vertex by vertex in increasing order by
// number.
for i := 1; i < maxBlockID-1; i++ {
return blocs
}
-// genManyPred creates an array of blocks where 1/3rd have a sucessor of the
+// genManyPred creates an array of blocks where 1/3rd have a successor of the
// first block, 1/3rd the last block, and the remaining third are plain.
func genManyPred(size int) []bloc {
var blocs []bloc
)
// We want predecessor lists to be long, so 2/3rds of the blocks have a
- // sucessor of the first or last block.
+ // successor of the first or last block.
for i := 0; i < size; i++ {
switch i % 3 {
case 0:
max = w
}
- // We can only guarantee that the loops runs withing limits of induction variable
+ // We can only guarantee that the loops runs within limits of induction variable
// if the increment is 1 or when the limits are constants.
if inc.AuxInt != 1 {
ok := false
}
}
-// TestNilcheckDomOrder ensures that the nil check elimination isn't dependant
+// TestNilcheckDomOrder ensures that the nil check elimination isn't dependent
// on the order of the dominees.
func TestNilcheckDomOrder(t *testing.T) {
ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
// domain represents the domain of a variable pair in which a set
// of relations is known. For example, relations learned for unsigned
-// pairs cannot be transfered to signed pairs because the same bit
+// pairs cannot be transferred to signed pairs because the same bit
// representation can mean something else.
type domain uint
type Package struct {
ImportPath string // import path denoting this package
Imports []string // packages imported by this package
- SymRefs []SymID // list of symbol names and versions refered to by this pack
+ SymRefs []SymID // list of symbol names and versions referred to by this pack
Syms []*Sym // symbols defined by this package
MaxVersion int // maximum Version in any SymID in Syms
}
r = ctxt.NewProg()
*r = *p
if !(r.Mark&FOLL != 0) {
- fmt.Printf("cant happen 1\n")
+ fmt.Printf("can't happen 1\n")
}
r.Mark |= FOLL
if p != q {
xfol(ctxt, r.Link, last)
}
if !(r.Pcond.Mark&FOLL != 0) {
- fmt.Printf("cant happen 2\n")
+ fmt.Printf("can't happen 2\n")
}
return
}
s.used.ireg |= 1 << uint(c-REG_R0)
}
}
- s.set.ireg &^= (1 << (REGZERO - REG_R0)) /* R0 cant be set */
+ s.set.ireg &^= (1 << (REGZERO - REG_R0)) /* R0 can't be set */
}
/*
r = ctxt.NewProg()
*r = *p
if r.Mark&FOLL == 0 {
- fmt.Printf("cant happen 1\n")
+ fmt.Printf("can't happen 1\n")
}
r.Mark |= FOLL
if p != q {
xfol(ctxt, r.Link, last)
}
if r.Pcond.Mark&FOLL == 0 {
- fmt.Printf("cant happen 2\n")
+ fmt.Printf("can't happen 2\n")
}
return
}
case 22: /* add $lcon,r1,r2 ==> cau+or+add */ /* could do add/sub more efficiently */
if p.To.Reg == REGTMP || p.Reg == REGTMP {
- ctxt.Diag("cant synthesize large constant\n%v", p)
+ ctxt.Diag("can't synthesize large constant\n%v", p)
}
d := vregoff(ctxt, &p.From)
o1 = loadu32(REGTMP, d)
case 23: /* and $lcon,r1,r2 ==> cau+or+and */ /* masks could be done using rlnm etc. */
if p.To.Reg == REGTMP || p.Reg == REGTMP {
- ctxt.Diag("cant synthesize large constant\n%v", p)
+ ctxt.Diag("can't synthesize large constant\n%v", p)
}
d := vregoff(ctxt, &p.From)
o1 = loadu32(REGTMP, d)
r = ctxt.NewProg()
*r = *p
if r.Mark&FOLL == 0 {
- fmt.Printf("cant happen 1\n")
+ fmt.Printf("can't happen 1\n")
}
r.Mark |= FOLL
if p != q {
xfol(ctxt, r.Link, last)
}
if r.Pcond.Mark&FOLL == 0 {
- fmt.Printf("cant happen 2\n")
+ fmt.Printf("can't happen 2\n")
}
return
}
r = ctxt.NewProg()
*r = *p
if r.Mark&FOLL == 0 {
- fmt.Printf("cant happen 1\n")
+ fmt.Printf("can't happen 1\n")
}
r.Mark |= FOLL
if p != q {
xfol(ctxt, r.Link, last)
}
if r.Pcond.Mark&FOLL == 0 {
- fmt.Printf("cant happen 2\n")
+ fmt.Printf("can't happen 2\n")
}
return
}
// deadcode marks all reachable symbols.
//
// The basis of the dead code elimination is a flood fill of symbols,
-// following their relocations, begining at INITENTRY.
+// following their relocations, beginning at INITENTRY.
//
// This flood fill is wrapped in logic for pruning unused methods.
// All methods are mentioned by relocations on their receiver's *rtype.
// if cond == 0 res <- b; else res <- a
func p256MovCond(res, a, b []uint64, cond int)
-// Endianess swap
+// Endianness swap
func p256BigToLittle(res []uint64, in []byte)
func p256LittleToBig(res []byte, in []uint64)
R_MIPS_LITERAL R_MIPS = 8 /* Reference to literal section */
R_MIPS_GOT16 R_MIPS = 9 /* Reference to global offset table */
R_MIPS_PC16 R_MIPS = 10 /* 16 bit PC relative reference */
- R_MIPS_CALL16 R_MIPS = 11 /* 16 bit call thru glbl offset tbl */
+ R_MIPS_CALL16 R_MIPS = 11 /* 16 bit call through glbl offset tbl */
R_MIPS_GPREL32 R_MIPS = 12
R_MIPS_SHIFT5 R_MIPS = 16
R_MIPS_SHIFT6 R_MIPS = 17
/* 19 */ {_SigNotify, "SIGPWR: power-fail restart"},
/* 20 */ {_SigNotify, "SIGWINCH: window size change"},
/* 21 */ {_SigNotify, "SIGURG: urgent socket condition"},
- /* 22 */ {_SigNotify, "SIGPOLL: pollable event occured"},
+ /* 22 */ {_SigNotify, "SIGPOLL: pollable event occurred"},
/* 23 */ {_SigNotify + _SigDefault, "SIGSTOP: stop (cannot be caught or ignored)"},
/* 24 */ {_SigNotify + _SigDefault, "SIGTSTP: user stop requested from tty"},
/* 25 */ {_SigNotify + _SigDefault, "SIGCONT: stopped process has been continued"},
// IsPseudo reports whether the header field is an http2 pseudo header.
// That is, it reports whether it starts with a colon.
-// It is not otherwise guaranteed to be a valid psuedo header field,
+// It is not otherwise guaranteed to be a valid pseudo header field,
// though.
func (hf HeaderField) IsPseudo() bool {
return len(hf.Name) != 0 && hf.Name[0] == ':'
panic("fail")
}
- // run it thru an interface
+ // run it through an interface
i = s
s = i.(*S)