}
for len(d) > 0 {
-
// ELF standards differ as to the sizes in
// note sections. Both the GNU linker and
// gold always generate 32-bit sizes, so that
// It returns the op and unparsed strings for typ, auxint, and aux restrictions and for all args.
// oparch is the architecture that op is located in, or "" for generic.
func parseValue(val string, arch arch, loc string) (op opData, oparch string, typ string, auxint string, aux string, args []string) {
-
// Resolve the op.
var s string
s, typ, auxint, aux, args = extract(val)
d := c.vregoff(p.GetFrom3())
var a int
switch p.As {
-
// These opcodes expect a mask operand that has to be converted into the
// appropriate operand. The way these were defined, not all valid masks are possible.
// Left here for compatibility in case they were used or generated.
c = 0
for p := s.Func.Text; p != nil; p = p.Link {
if ctxt.Headtype == objabi.Hnacl && p.Isize > 0 {
-
// pad everything to avoid crossing 32-byte boundary
if c>>5 != (c+int32(p.Isize)-1)>>5 {
c = naclpad(ctxt, s, c, -c&31)
// Only break at outermost syms.
if ctxt.Arch.InFamily(sys.PPC64) && s.Outer == nil && ctxt.IsELF && ctxt.LinkMode == LinkExternal && va-sect.Vaddr+funcsize+maxSizeTrampolinesPPC64(s, isTramp) > 0x1c00000 {
-
// Set the length for the previous text section
sect.Length = va - sect.Vaddr
// resolve direct jump relocation r in s, and add trampoline if necessary
func trampoline(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol) {
-
// Trampolines are created if the branch offset is too large and the linker cannot insert a call stub to handle it.
// For internal linking, trampolines are always created for long calls.
// For external linking, the linker can insert a call stub to handle a long call, but depends on having the TOC address in
if (ctxt.LinkMode == ld.LinkExternal && s.Sect != r.Sym.Sect) || (ctxt.LinkMode == ld.LinkInternal && int64(int32(t<<6)>>6) != t) || (*ld.FlagDebugTramp > 1 && s.File != r.Sym.File) {
var tramp *sym.Symbol
for i := 0; ; i++ {
-
// Using r.Add as part of the name is significant in functions like duffzero where the call
// target is at some offset within the function. Calls to duff+8 and duff+256 must appear as
// distinct trampolines.
dlen := 8
for j := 0; j < 8; {
-
// We have reached the end and are missing padding
if len(src) == 0 && enc.padChar != NoPadding {
return n, false, CorruptInputError(olen - len(src) - j)
H uint32
A uint8
+
// contains filtered or unexported fields
}
H uint32
A uint8
+
// contains filtered or unexported fields
}
// B is a type passed to Benchmark functions to manage benchmark ...
type B struct {
N int
+
// contains filtered or unexported fields
}
// B is a type passed to Benchmark functions to manage benchmark ...
type B struct {
N int
+
// contains filtered or unexported fields
}
if isIncomplete {
if len(list) > 0 {
p.print(formfeed)
+ p.print(newline)
}
p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment
p.setLineComment("// contains filtered or unexported fields")
if isIncomplete {
if len(list) > 0 {
p.print(formfeed)
+ p.print(newline)
}
p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment
p.setLineComment("// contains filtered or unexported methods")
mode pmode // current printer mode
impliedSemi bool // if set, a linebreak implies a semicolon
lastTok token.Token // last token printed (token.ILLEGAL if it's whitespace)
- prevOpen token.Token // previous non-brace "open" token (, [, or token.ILLEGAL
+ prevOpen token.Token // previous "open" token: (, [, {, or token.ILLEGAL
wsbuf []whiteSpace // delayed white space
// Positions
n := 0
if pos.IsValid() && p.last.IsValid() {
n = pos.Line - p.last.Line
+ if n > 1 && p.prevOpen != token.ILLEGAL && prev == nil {
+ // Forbid multiple empty lines from appearing immediately
+ // following some type of open paren, bracket, or brace.
+ n = 1
+ }
if n < 0 { // should never happen
n = 0
}
switch p.lastTok {
case token.ILLEGAL:
// ignore (white space)
- case token.LPAREN, token.LBRACK:
+ case token.LPAREN, token.LBRACK, token.LBRACE:
p.prevOpen = p.lastTok
default:
// other tokens followed any opening token
f3 int // f3 is not exported
}
+type T struct { // foo
+
+ // bar
+ x int
+ X int
+}
+
+type T struct { /* foo */
+
+ // bar
+ x int
+}
+
+type T struct { // foo
+
+ x int
+
+ X int
+}
+
+type T struct { /* foo */
+
+ x int
+}
+
+type T struct {
+ x int
+}
+
+type T struct {
+ x int
+}
+
+type T struct{ x int }
+
+type T struct {
+ x int
+}
+
+type T struct {
+ x int
+ X int
+ x int
+}
+
+type T struct {
+ // Comment
+ x int
+ // X.
+ X int
+ // Comment
+ x int
+}
+
+const ( // foo
+
+ // bar
+ x int = 0
+ X int = 0
+)
+
+const ( /* foo */
+
+ // bar
+ x int = 0
+)
+
+const ( // foo
+
+ x int = 0
+
+ X int = 0
+)
+
+const ( /* foo */
+
+ x int = 0
+)
+
+const (
+ x int = 0
+)
+
+const (
+ x int = 0
+ X int = 0
+)
+
+const (
+ x int = 0
+ X int = 0
+ x int = 0
+)
+
+const (
+ // Comment
+ x int = 0
+ // X.
+ X int = 0
+ // Comment
+ x int = 0
+)
+
// This comment group should be separated
// with a newline from the next comment
// group.
f3 int // f3 is not exported
}
+type T struct { // foo
+
+ // bar
+ x int
+ X int
+}
+
+type T struct { /* foo */
+
+ // bar
+ x int
+}
+
+type T struct { // foo
+
+ x int
+
+ X int
+}
+
+type T struct { /* foo */
+
+
+
+x int
+}
+
+type T struct {x int
+}
+
+type T struct {
+ x int}
+
+type T struct {x int}
+
+type T struct {
+
+ x int
+}
+
+type T struct {
+ x int
+ X int
+ x int
+}
+
+type T struct {
+ // Comment
+ x int
+ // X.
+ X int
+ // Comment
+ x int
+}
+
+const ( // foo
+
+ // bar
+ x int = 0
+ X int = 0
+)
+
+const ( /* foo */
+
+ // bar
+ x int = 0
+)
+
+const ( // foo
+
+ x int = 0
+
+ X int = 0
+)
+
+const ( /* foo */
+
+ x int = 0
+)
+
+const (
+
+ x int = 0
+)
+
+const (
+
+ x int = 0
+ X int = 0
+
+)
+
+const (
+ x int = 0
+ X int = 0
+ x int = 0
+)
+
+const (
+ // Comment
+ x int = 0
+ // X.
+ X int = 0
+ // Comment
+ x int = 0
+)
+
// This comment group should be separated
// with a newline from the next comment
// group.
F2 int // line comment for F2
// contains filtered or unexported fields
}
+
+type T struct {
+ X int
+
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ X int
+
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ X int
+
+ // contains filtered or unexported fields
+}
+
+type T struct {
+ // X.
+ X int
+
+ // contains filtered or unexported fields
+}
+
+const (
+ X int = 0
+)
+
+const (
+ X int = 0
+)
+
+const (
+ X int = 0
+)
+
+const (
+ X int = 0
+)
+
+const (
+ // X.
+ X int = 0
+)
// archUpdateIEEE calculates the checksum of p using vectorizedIEEE.
func archUpdateIEEE(crc uint32, p []byte) uint32 {
-
// Check if vector code should be used. If not aligned, then handle those
// first up to the aligned bytes.
ci := (sy-src.Rect.Min.Y)*src.CStride + (sp.X - src.Rect.Min.X)
for x := x0; x != x1; x, yi, ci = x+4, yi+1, ci+1 {
-
// This is an inline version of image/color/ycbcr.go's func YCbCrToRGB.
yy1 := int32(src.Y[yi]) * 0x10101
cb1 := int32(src.Cb[ci]) - 128
ci := (sy/2-src.Rect.Min.Y/2)*src.CStride + (sp.X - src.Rect.Min.X)
for x := x0; x != x1; x, yi, ci = x+4, yi+1, ci+1 {
-
// This is an inline version of image/color/ycbcr.go's func YCbCrToRGB.
yy1 := int32(src.Y[yi]) * 0x10101
cb1 := int32(src.Cb[ci]) - 128
}
var dumpTests = []dumpTest{
-
// HTTP/1.1 => chunked coding; body; empty trailer
{
Req: http.Request{
// Response.Close field to true. Write should be considered operational until
// it returns an error, regardless of any errors returned on the Read side.
func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error {
-
// Retrieve the pipeline ID of this request/response pair
sc.mu.Lock()
id, ok := sc.pipereq[req]
// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
// a bug since it does not check for success of io.WriteString
func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
-
// Don't send 0-length data. It looks like EOF for chunked encoding.
if len(data) == 0 {
return 0, nil
// try to restore it. It always dumps the whole body.
// And it doesn't support https.
func dumpRequestOut(req *Request, onReadHeaders func()) ([]byte, error) {
-
// Use the actual Transport code to record what we would send
// on the wire, but not using TCP. Use a Transport with a
// custom dialer that returns a fake net.Conn that waits
// If there is no registered handler that applies to the request,
// Handler returns a ``page not found'' handler and an empty pattern.
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
-
// CONNECT requests are not canonicalized.
if r.Method == "CONNECT" {
// If r.URL.Path is /tree and its handler is not registered,
// Check if all valid addresses can be parsed, formatted and parsed again
func TestAddressParsingAndFormatting(t *testing.T) {
-
// Should pass
tests := []string{
`<Bob@example.com>`,
// cleanClass sorts the ranges (pairs of elements of r),
// merges them, and eliminates duplicates.
func cleanClass(rp *[]rune) []rune {
-
// Sort by lo increasing, hi decreasing to break ties.
sort.Sort(ranges{rp})
idx = uint32(len(datap.ftab) - 1)
}
if pc < datap.ftab[idx].entry {
-
// With multiple text sections, the idx might reference a function address that
// is higher than the pc being searched, so search backward until the matching address is found.
throw("findfunc: bad findfunctab entry idx")
}
} else {
-
// linear search to find func with pc >= entry.
for datap.ftab[idx+1].entry <= pc {
idx++
}
func nametomib(name string) (mib []_C_int, err error) {
-
// Split name into components.
var parts []string
last := 0
func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
func nametomib(name string) (mib []_C_int, err error) {
-
// Perform lookup via a binary search
left := 0
right := len(sysctlMib) - 1
}
func benchmark(b *testing.B, bench func(n int)) {
-
// Create equal number of garbage timers on each P before starting
// the benchmark.
var wg sync.WaitGroup
// Functions starting with "Is" can be used to inspect which table of range a
// rune belongs to. Note that runes may fit into more than one range.
func Example_is() {
-
// constant with mixed type runes
const mixed = "\b5Ὂg̀9! ℃ᾭG"
for _, c := range mixed {