src/cmd/gc/opnames.h
src/cmd/gc/y.output
src/cmd/go/zdefaultcc.go
-src/pkg/go/doc/headscan
-src/pkg/runtime/goc2c
-src/pkg/runtime/mkversion
-src/pkg/runtime/z*
-src/pkg/unicode/maketables
-src/pkg/*.*/
+src/go/doc/headscan
+src/runtime/goc2c
+src/runtime/mkversion
+src/runtime/z*
+src/unicode/maketables
+src/*.*/
test/pass.out
test/run.out
test/times.out
in a known way from the import path. Specifically, the first choice
is <code>$GOPATH/src/<import-path></code>. If <code>$GOPATH</code> is
unset, the go command will fall back to storing source code alongside the
-standard Go packages, in <code>$GOROOT/src/pkg/<import-path></code>.
+standard Go packages, in <code>$GOROOT/src/<import-path></code>.
If <code>$GOPATH</code> is set to a list of paths, the go command tries
<code><dir>/src/<import-path></code> for each of the directories in
that list.</p>
WARNING: DATA RACE
Read by goroutine 185:
net.(*pollServer).AddFD()
- src/pkg/net/fd_unix.go:89 +0x398
+ src/net/fd_unix.go:89 +0x398
net.(*pollServer).WaitWrite()
- src/pkg/net/fd_unix.go:247 +0x45
+ src/net/fd_unix.go:247 +0x45
net.(*netFD).Write()
- src/pkg/net/fd_unix.go:540 +0x4d4
+ src/net/fd_unix.go:540 +0x4d4
net.(*conn).Write()
- src/pkg/net/net.go:129 +0x101
+ src/net/net.go:129 +0x101
net.func·060()
- src/pkg/net/timeout_test.go:603 +0xaf
+ src/net/timeout_test.go:603 +0xaf
Previous write by goroutine 184:
net.setWriteDeadline()
- src/pkg/net/sockopt_posix.go:135 +0xdf
+ src/net/sockopt_posix.go:135 +0xdf
net.setDeadline()
- src/pkg/net/sockopt_posix.go:144 +0x9c
+ src/net/sockopt_posix.go:144 +0x9c
net.(*conn).SetDeadline()
- src/pkg/net/net.go:161 +0xe3
+ src/net/net.go:161 +0xe3
net.func·061()
- src/pkg/net/timeout_test.go:616 +0x3ed
+ src/net/timeout_test.go:616 +0x3ed
Goroutine 185 (running) created at:
net.func·061()
- src/pkg/net/timeout_test.go:609 +0x288
+ src/net/timeout_test.go:609 +0x288
Goroutine 184 (running) created at:
net.TestProlongTimeout()
- src/pkg/net/timeout_test.go:618 +0x298
+ src/net/timeout_test.go:618 +0x298
testing.tRunner()
- src/pkg/testing/testing.go:301 +0xe8
+ src/testing/testing.go:301 +0xe8
</pre>
<h2 id="Options">Options</h2>
<enter description here>
Files:
- src/pkg/math/sin.go
- src/pkg/math/tan.go
- src/pkg/regexp/regexp.go
+ src/math/sin.go
+ src/math/tan.go
+ src/regexp/regexp.go
</pre>
<p>
Fixes issue 159.
Files:
- src/pkg/math/sin.go
- src/pkg/math/tan.go
+ src/math/sin.go
+ src/math/tan.go
</pre>
<p>
adding manifests
adding file changes
added 1 changeset with 2 changes to 2 files
-getting src/pkg/flag/flag.go
+getting src/flag/flag.go
couldn't find merge tool hgmerge
-merging src/pkg/flag/flag_test.go
+merging src/flag/flag_test.go
warning: conflicts during merge.
-<i>merging src/pkg/flag/flag_test.go failed!</i>
+<i>merging src/flag/flag_test.go failed!</i>
1 file updated, 0 files merged, 0 files removed, 1 file unresolved
use 'hg resolve' to retry unresolved file merges
$
<p>
If you'd like to see how this works, or want to extend it, take a look at <a
-href="/src/pkg/runtime/runtime-gdb.py">src/pkg/runtime/runtime-gdb.py</a> in
+href="/src/runtime/runtime-gdb.py">src/runtime/runtime-gdb.py</a> in
the Go source distribution. It depends on some special magic types
(<code>hash<T,U></code>) and variables (<code>runtime.m</code> and
<code>runtime.g</code>) that the linker
<p>
In this tutorial we will inspect the binary of the
<a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
-change to <code>$GOROOT/src/pkg/regexp</code> and run <code>go test -c</code>.
+change to <code>$GOROOT/src/regexp</code> and run <code>go test -c</code>.
This should produce an executable file named <code>regexp.test</code>.
</p>
Type "show copying" and "show warranty" for licensing/warranty details.
This GDB was configured as "x86_64-linux".
-Reading symbols from /home/user/go/src/pkg/regexp/regexp.test...
+Reading symbols from /home/user/go/src/regexp/regexp.test...
done.
Loading Go Runtime support.
(gdb)
<p>
The message <code>"Loading Go Runtime support"</code> means that GDB loaded the
-extension from <code>$GOROOT/src/pkg/runtime/runtime-gdb.py</code>.
+extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
</p>
<p>
</p>
<pre>
-(gdb) <b>source ~/go/src/pkg/runtime/runtime-gdb.py</b>
+(gdb) <b>source ~/go/src/runtime/runtime-gdb.py</b>
Loading Go Runtime support.
</pre>
<pre>
(gdb) <b>b 'regexp.TestFind'</b>
-Breakpoint 1 at 0x424908: file /home/user/go/src/pkg/regexp/find_test.go, line 148.
+Breakpoint 1 at 0x424908: file /home/user/go/src/regexp/find_test.go, line 148.
</pre>
<p>
<pre>
(gdb) <b>run</b>
-Starting program: /home/user/go/src/pkg/regexp/regexp.test
+Starting program: /home/user/go/src/regexp/regexp.test
-Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/pkg/regexp/find_test.go:148
+Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
148 func TestFind(t *testing.T) {
</pre>
<pre>
(gdb) <b>bt</b> <i># backtrace</i>
-#0 regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/pkg/regexp/find_test.go:148
-#1 0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/pkg/testing/testing.go:156
-#2 0x000000000040df64 in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:242
+#0 regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
+#1 0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/testing/testing.go:156
+#2 0x000000000040df64 in runtime.initdone () at /home/user/go/src/runtime/proc.c:242
#3 0x000000f8404a89c0 in ?? ()
#4 0x0000000000573720 in ?? ()
#5 0x0000000000000000 in ?? ()
<pre>
(gdb) <b>goroutine 1 bt</b>
-#0 0x000000000040facb in runtime.gosched () at /home/user/go/src/pkg/runtime/proc.c:873
+#0 0x000000000040facb in runtime.gosched () at /home/user/go/src/runtime/proc.c:873
#1 0x00000000004031c9 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
- at /home/user/go/src/pkg/runtime/chan.c:342
-#2 0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/pkg/runtime/chan.c:423
+ at /home/user/go/src/runtime/chan.c:342
+#2 0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/runtime/chan.c:423
#3 0x000000000043075b in testing.RunTests (matchString={void (struct string, struct string, bool *, error *)}
- 0x7ffff7f9ef60, tests= []testing.InternalTest = {...}) at /home/user/go/src/pkg/testing/testing.go:201
+ 0x7ffff7f9ef60, tests= []testing.InternalTest = {...}) at /home/user/go/src/testing/testing.go:201
#4 0x00000000004302b1 in testing.Main (matchString={void (struct string, struct string, bool *, error *)}
0x7ffff7f9ef80, tests= []testing.InternalTest = {...}, benchmarks= []testing.InternalBenchmark = {...})
-at /home/user/go/src/pkg/testing/testing.go:168
-#5 0x0000000000400dc1 in main.main () at /home/user/go/src/pkg/regexp/_testmain.go:98
-#6 0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/pkg/runtime/amd64/asm.s:78
-#7 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:243
+at /home/user/go/src/testing/testing.go:168
+#5 0x0000000000400dc1 in main.main () at /home/user/go/src/regexp/_testmain.go:98
+#6 0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/runtime/amd64/asm.s:78
+#7 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
#8 0x0000000000000000 in ?? ()
</pre>
<pre>
(gdb) <b>info frame</b>
Stack level 0, frame at 0x7ffff7f9ff88:
- rip = 0x425530 in regexp.TestFind (/home/user/go/src/pkg/regexp/find_test.go:148);
+ rip = 0x425530 in regexp.TestFind (/home/user/go/src/regexp/find_test.go:148);
saved rip 0x430233
called by frame at 0x7ffff7f9ffa8
source language minimal.
<pre>
(gdb) <b>s</b>
-regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/pkg/regexp/regexp.go:97
+regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/regexp/regexp.go:97
97 func (re *Regexp) String() string {
</pre>
<pre>
(gdb) <b>bt</b>
#0 regexp.(*Regexp).String (re=0xf84068d070, noname=void)
- at /home/user/go/src/pkg/regexp/regexp.go:97
+ at /home/user/go/src/regexp/regexp.go:97
#1 0x0000000000425615 in regexp.TestFind (t=0xf840688b60)
- at /home/user/go/src/pkg/regexp/find_test.go:151
+ at /home/user/go/src/regexp/find_test.go:151
#2 0x0000000000430233 in testing.tRunner (t=0xf840688b60, test=0x5747b8)
- at /home/user/go/src/pkg/testing/testing.go:156
-#3 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:243
+ at /home/user/go/src/testing/testing.go:156
+#3 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
....
</pre>
<h3 id="examples">Examples</h3>
<p>
-The <a href="/src/pkg/">Go package sources</a>
+The <a href="/src/">Go package sources</a>
are intended to serve not
only as the core library but also as examples of how to
use the language.
<p>
Another convention is that the package name is the base name of
its source directory;
-the package in <code>src/pkg/encoding/base64</code>
+the package in <code>src/encoding/base64</code>
is imported as <code>"encoding/base64"</code> but has name <code>base64</code>,
not <code>encoding_base64</code> and not <code>encodingBase64</code>.
</p>
should be made in the main Go repository. The files outside
of <code>libgo/go</code> are gccgo-specific; that said, some of the
files in <code>libgo/runtime</code> are based on files
-in <code>src/pkg/runtime</code> in the main Go repository.
+in <code>src/runtime</code> in the main Go repository.
</p>
<h2>Testing</h2>
How do I submit patches to the Go libraries?</h3>
<p>
-The library sources are in <code>go/src/pkg</code>.
+The library sources are in <code>go/src</code>.
If you want to make a significant change, please discuss on the mailing list before embarking.
</p>
in a data structure (Go has excellent support for data structure literals).
The work to write a good test and good error messages will then be amortized over many
test cases. The standard Go library is full of illustrative examples, such as in
-<a href="/src/pkg/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
+<a href="/src/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
</p>
// Determine thepackage by examining the current working
// directory, which will look something like
- // "$GOROOT/src/pkg/mime/multipart". We extract everything
+ // "$GOROOT/src/mime/multipart". We extract everything
// after the $GOROOT to run on the same relative directory
// on the target device.
//
"misc/dashboard/godashboard",
"src/cmd/cov",
"src/cmd/prof",
- "src/pkg/exp",
- "src/pkg/old",
+ "src/exp",
+ "src/old",
}
var cleanFiles = []string{
export ANDROID_PRODUCT_OUT=/tmp/androidtest-$$
FAKE_GOROOT=$ANDROID_PRODUCT_OUT/data/local/tmp/goroot
mkdir -p $FAKE_GOROOT/src
-ln -s $GOROOT/src/cmd $FAKE_GOROOT/src/cmd
-ln -s $GOROOT/src/pkg $FAKE_GOROOT/src/pkg
+ln -s $GOROOT/src $FAKE_GOROOT/src
ln -s $GOROOT/test $FAKE_GOROOT/test
ln -s $GOROOT/lib $FAKE_GOROOT/lib
echo '# Syncing test files to android device'
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
%}
%union
{
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
/* Line 371 of yacc.c */
#line 76 "y.tab.c"
// THE SOFTWARE.
#include "gc.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
void
_cgen(Node *n, Node *nn, int inrel)
f = sysfunc("duffcopy");
p = gins(ADUFFCOPY, N, f);
afunclit(&p->to, f);
- // 8 and 128 = magic constants: see ../../pkg/runtime/asm_arm.s
+ // 8 and 128 = magic constants: see ../../runtime/asm_arm.s
p->to.offset = 8*(128-c);
regfree(&tmp);
f = sysfunc("duffzero");
p = gins(ADUFFZERO, N, f);
afunclit(&p->to, f);
- // 4 and 128 = magic constants: see ../../pkg/runtime/asm_arm.s
+ // 4 and 128 = magic constants: see ../../runtime/asm_arm.s
p->to.offset = 4*(128-q);
} else
while(q > 0) {
#include <u.h>
#include <libc.h>
#include "gg.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
// TODO(rsc): Can make this bigger if we move
// the text segment up higher in 5l for all GOOS.
-// At the same time, can raise StackBig in ../../pkg/runtime/stack.h.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
long unmappedzero = 4096;
void
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
%}
%union {
Sym *sym;
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
/* Enabling traces. */
// THE SOFTWARE.
#include "gc.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
/* ,x/^(print|prtree)\(/i/\/\/ */
int castup(Type*, Type*);
// THE SOFTWARE.
#include "gc.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
Prog*
gtext(Sym *s, int32 stkoff)
p = gins(ADUFFCOPY, N, N);
p->to.type = D_ADDR;
p->to.sym = linksym(pkglookup("duffcopy", runtimepkg));
- // 14 and 128 = magic constants: see ../../pkg/runtime/asm_amd64.s
+ // 14 and 128 = magic constants: see ../../runtime/asm_amd64.s
p->to.offset = 14*(128-q);
} else
while(q > 0) {
p = gins(ADUFFZERO, N, N);
p->to.type = D_ADDR;
p->to.sym = linksym(pkglookup("duffzero", runtimepkg));
- // 2 and 128 = magic constants: see ../../pkg/runtime/asm_amd64.s
+ // 2 and 128 = magic constants: see ../../runtime/asm_amd64.s
p->to.offset = 2*(128-q);
} else
while(q > 0) {
#include <u.h>
#include <libc.h>
#include "gg.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
// TODO(rsc): Can make this bigger if we move
// the text segment up higher in 6l for all GOOS.
-// At the same time, can raise StackBig in ../../pkg/runtime/stack.h.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
vlong unmappedzero = 4096;
void
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
%}
%union {
Sym *sym;
#include <stdio.h> /* if we don't, bison will, and a.h re-#defines getc */
#include <libc.h>
#include "a.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
/* Enabling traces. */
// THE SOFTWARE.
#include "gc.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
/* ,x/^(print|prtree)\(/i/\/\/ */
p = gins(ADUFFCOPY, N, N);
p->to.type = D_ADDR;
p->to.sym = linksym(pkglookup("duffcopy", runtimepkg));
- // 10 and 128 = magic constants: see ../../pkg/runtime/asm_386.s
+ // 10 and 128 = magic constants: see ../../runtime/asm_386.s
p->to.offset = 10*(128-q);
} else
while(q > 0) {
p = gins(ADUFFZERO, N, N);
p->to.type = D_ADDR;
p->to.sym = linksym(pkglookup("duffzero", runtimepkg));
- // 1 and 128 = magic constants: see ../../pkg/runtime/asm_386.s
+ // 1 and 128 = magic constants: see ../../runtime/asm_386.s
p->to.offset = 1*(128-q);
} else
while(q > 0) {
#include <u.h>
#include <libc.h>
#include "gg.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
// TODO(rsc): Can make this bigger if we move
// the text segment up higher in 8l for all GOOS.
-// At the same time, can raise StackBig in ../../pkg/runtime/stack.h.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
uint32 unmappedzero = 4096;
#define CASE(a,b) (((a)<<16)|((b)<<0))
var featureCtx = make(map[string]map[string]bool) // feature -> context name -> true
for _, context := range contexts {
- w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src/pkg"))
+ w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src"))
for _, name := range pkgNames {
// - Package "unsafe" contains special signatures requiring
continue
}
- goldenFile := filepath.Join("testdata", "src", "pkg", fi.Name(), "golden.txt")
+ goldenFile := filepath.Join("testdata", "src", fi.Name(), "golden.txt")
w := NewWalker(nil, "testdata/src/pkg")
w.export(w.Import(fi.Name()))
for i := 0; i < b.N; i++ {
for _, context := range contexts {
- w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src/pkg"))
+ w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src"))
for _, name := range pkgNames {
if name != "unsafe" && !strings.HasPrefix(name, "cmd/") {
w.export(w.Import(name))
// THE SOFTWARE.
#include "gc.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
enum { BitsPerPointer = 2 };
case nil:
- // These are ordered and grouped to match ../../pkg/go/ast/ast.go
+ // These are ordered and grouped to match ../../go/ast/ast.go
case *ast.Field:
if len(n.Names) == 0 && context == "field" {
f.walk(&n.Type, "embed-type", visit)
// not be in release branches.
static char *unreleased[] = {
"src/cmd/link",
- "src/pkg/debug/goobj",
- "src/pkg/old",
+ "src/debug/goobj",
+ "src/old",
};
// setup sets up the tree for the initial build.
"$GOROOT/pkg/obj/$GOHOSTOS_$GOHOSTARCH/libbio.a",
"$GOROOT/pkg/obj/$GOHOSTOS_$GOHOSTARCH/lib9.a",
}},
- {"pkg/runtime", {
+ {"runtime", {
"zaexperiment.h", // must sort above zasm
"zasm_$GOOS_$GOARCH.h",
"zsys_$GOOS_$GOARCH.s",
}
islib = hasprefix(dir, "lib") || streq(dir, "cmd/cc") || streq(dir, "cmd/gc");
- ispkg = hasprefix(dir, "pkg");
+ ispkg = !islib && !hasprefix(dir, "cmd/");
isgo = ispkg || streq(dir, "cmd/go") || streq(dir, "cmd/cgo");
exe = "";
// Go library (package).
ispackcmd = 1;
vadd(&link, "pack"); // program name - unused here, but all the other cases record one
- p = bprintf(&b, "%s/pkg/%s_%s/%s", goroot, goos, goarch, dir+4);
+ p = bprintf(&b, "%s/pkg/%s_%s/%s", goroot, goos, goarch, dir);
*xstrrchr(p, '/') = '\0';
xmkdirall(p);
targ = link.len;
- vadd(&link, bpathf(&b, "%s/pkg/%s_%s/%s.a", goroot, goos, goarch, dir+4));
+ vadd(&link, bpathf(&b, "%s/pkg/%s_%s/%s.a", goroot, goos, goarch, dir));
} else if(streq(dir, "cmd/go") || streq(dir, "cmd/cgo")) {
// Go command.
vadd(&link, bpathf(&b, "%s/%sl", tooldir, gochar));
goto out;
// For package runtime, copy some files into the work space.
- if(streq(dir, "pkg/runtime")) {
+ if(streq(dir, "runtime")) {
copyfile(bpathf(&b, "%s/arch_GOARCH.h", workdir),
bpathf(&b1, "%s/arch_%s.h", bstr(&path), goarch), 0);
copyfile(bpathf(&b, "%s/defs_GOOS_GOARCH.h", workdir),
errprintf("generate %s\n", p);
gentab[j].gen(bstr(&path), p);
// Do not add generated file to clean list.
- // In pkg/runtime, we want to be able to
+ // In runtime, we want to be able to
// build the package with the go tool,
// and it assumes these generated files already
// exist (it does not know how to build them).
// One more copy for package runtime.
// The last batch was required for the generators.
// This one is generated.
- if(streq(dir, "pkg/runtime")) {
+ if(streq(dir, "runtime")) {
copyfile(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir),
bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0);
}
else
vadd(&compile, "main");
- if(streq(dir, "pkg/runtime"))
+ if(streq(dir, "runtime"))
vadd(&compile, "-+");
vcopy(&compile, go.p, go.len);
nobuild:
// In package runtime, we install runtime.h and cgocall.h too,
// for use by cgo compilation.
- if(streq(dir, "pkg/runtime")) {
+ if(streq(dir, "runtime")) {
copyfile(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
- bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0);
+ bpathf(&b1, "%s/src/runtime/cgocall.h", goroot), 0);
copyfile(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
- bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0);
+ bpathf(&b1, "%s/src/runtime/runtime.h", goroot), 0);
}
// back when there were build scripts. Will have to
// be maintained by hand, but shouldn't change very
// often.
- "pkg/runtime",
- "pkg/errors",
- "pkg/sync/atomic",
- "pkg/sync",
- "pkg/io",
- "pkg/unicode",
- "pkg/unicode/utf8",
- "pkg/unicode/utf16",
- "pkg/bytes",
- "pkg/math",
- "pkg/strings",
- "pkg/strconv",
- "pkg/bufio",
- "pkg/sort",
- "pkg/container/heap",
- "pkg/encoding/base64",
- "pkg/syscall",
- "pkg/time",
- "pkg/os",
- "pkg/reflect",
- "pkg/fmt",
- "pkg/encoding",
- "pkg/encoding/json",
- "pkg/flag",
- "pkg/path/filepath",
- "pkg/path",
- "pkg/io/ioutil",
- "pkg/log",
- "pkg/regexp/syntax",
- "pkg/regexp",
- "pkg/go/token",
- "pkg/go/scanner",
- "pkg/go/ast",
- "pkg/go/parser",
- "pkg/os/exec",
- "pkg/os/signal",
- "pkg/net/url",
- "pkg/text/template/parse",
- "pkg/text/template",
- "pkg/go/doc",
- "pkg/go/build",
+ "runtime",
+ "errors",
+ "sync/atomic",
+ "sync",
+ "io",
+ "unicode",
+ "unicode/utf8",
+ "unicode/utf16",
+ "bytes",
+ "math",
+ "strings",
+ "strconv",
+ "bufio",
+ "sort",
+ "container/heap",
+ "encoding/base64",
+ "syscall",
+ "time",
+ "os",
+ "reflect",
+ "fmt",
+ "encoding",
+ "encoding/json",
+ "flag",
+ "path/filepath",
+ "path",
+ "io/ioutil",
+ "log",
+ "regexp/syntax",
+ "regexp",
+ "go/token",
+ "go/scanner",
+ "go/ast",
+ "go/parser",
+ "os/exec",
+ "os/signal",
+ "net/url",
+ "text/template/parse",
+ "text/template",
+ "go/doc",
+ "go/build",
"cmd/go",
};
// It is bigger than the buildorder because we clean all the
// compilers but build only the $GOARCH ones.
static char *cleantab[] = {
+ // Commands and C libraries.
"cmd/5a",
"cmd/5c",
"cmd/5g",
"lib9",
"libbio",
"liblink",
- "pkg/bufio",
- "pkg/bytes",
- "pkg/container/heap",
- "pkg/encoding",
- "pkg/encoding/base64",
- "pkg/encoding/json",
- "pkg/errors",
- "pkg/flag",
- "pkg/fmt",
- "pkg/go/ast",
- "pkg/go/build",
- "pkg/go/doc",
- "pkg/go/parser",
- "pkg/go/scanner",
- "pkg/go/token",
- "pkg/io",
- "pkg/io/ioutil",
- "pkg/log",
- "pkg/math",
- "pkg/net/url",
- "pkg/os",
- "pkg/os/exec",
- "pkg/path",
- "pkg/path/filepath",
- "pkg/reflect",
- "pkg/regexp",
- "pkg/regexp/syntax",
- "pkg/runtime",
- "pkg/sort",
- "pkg/strconv",
- "pkg/strings",
- "pkg/sync",
- "pkg/sync/atomic",
- "pkg/syscall",
- "pkg/text/template",
- "pkg/text/template/parse",
- "pkg/time",
- "pkg/unicode",
- "pkg/unicode/utf16",
- "pkg/unicode/utf8",
+
+ // Go packages.
+ "bufio",
+ "bytes",
+ "container/heap",
+ "encoding",
+ "encoding/base64",
+ "encoding/json",
+ "errors",
+ "flag",
+ "fmt",
+ "go/ast",
+ "go/build",
+ "go/doc",
+ "go/parser",
+ "go/scanner",
+ "go/token",
+ "io",
+ "io/ioutil",
+ "log",
+ "math",
+ "net/url",
+ "os",
+ "os/exec",
+ "path",
+ "path/filepath",
+ "reflect",
+ "regexp",
+ "regexp/syntax",
+ "runtime",
+ "sort",
+ "strconv",
+ "strings",
+ "sync",
+ "sync/atomic",
+ "syscall",
+ "text/template",
+ "text/template/parse",
+ "time",
+ "unicode",
+ "unicode/utf16",
+ "unicode/utf8",
};
static void
xremove(bpathf(&b, "%s/%s", bstr(&path), cleantab[i]+4));
}
- // remove src/pkg/runtime/z* unconditionally
+ // remove src/runtime/z* unconditionally
vreset(&dir);
- bpathf(&path, "%s/src/pkg/runtime", goroot);
+ bpathf(&path, "%s/src/runtime", goroot);
xreaddir(&dir, bstr(&path));
for(j=0; j<dir.len; j++) {
if(hasprefix(dir.p[j], "z"))
if(argc > 0)
usage();
+ if(isdir(bpathf(&b, "%s/src/pkg", goroot))) {
+ fatal("\n\n"
+ "The Go package sources have moved to $GOROOT/src.\n"
+ "*** %s still exists. ***\n"
+ "It probably contains stale files that may confuse the build.\n"
+ "Please (check what's there and) remove it and try again.\n"
+ "See http://golang.org/s/go14nopkg\n", bpathf(&b, "%s/src/pkg", goroot));
+ }
+
if(rebuildall)
clean();
goversion = findgoversion();
xsetenv("GOARCH", goarch);
xsetenv("GOOS", goos);
- // Build pkg/runtime for actual goos/goarch too.
+ // Build runtime for actual goos/goarch too.
if(!streq(goos, gohostos) || !streq(goarch, gohostarch))
- install("pkg/runtime");
+ install("runtime");
bfree(&b);
}
#include "a.h"
/*
- * Helpers for building pkg/runtime.
+ * Helpers for building runtime.
*/
// mkzversion writes zversion.go:
return 1;
torune(&ru, f1);
- // refer to ../../pkg/os/stat_windows.go:/sameFile
+ // refer to ../../os/stat_windows.go:/sameFile
fd1 = CreateFileW(ru, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
xfree(ru);
if(fd1 == INVALID_HANDLE_VALUE)
case *[]ast.Stmt:
walkBeforeAfter(*n, before, after)
- // These are ordered and grouped to match ../../pkg/go/ast/ast.go
+ // These are ordered and grouped to match ../../go/ast/ast.go
case *ast.Field:
walkBeforeAfter(&n.Names, before, after)
walkBeforeAfter(&n.Type, before, after)
// license that can be found in the LICENSE file.
// 64-bit MD5 (does full MD5 but returns 64 bits only).
-// Translation of ../../pkg/crypto/md5/md5*.go.
+// Translation of ../../crypto/md5/md5*.go.
#include <u.h>
#include <libc.h>
#include "md5.h"
#include "gg.h"
#include "opt.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
static void allocauto(Prog* p);
ptxt->TEXTFLAG |= NOSPLIT;
// Clumsy but important.
- // See test/recover.go for test cases and src/pkg/reflect/value.go
+ // See test/recover.go for test cases and src/reflect/value.go
// for the actual functions being considered.
if(myimportpath != nil && strcmp(myimportpath, "reflect") == 0) {
if(strcmp(curfn->nname->sym->name, "callReflect") == 0 || strcmp(curfn->nname->sym->name, "callMethod") == 0)
#include "gg.h"
#include "opt.h"
#include "../ld/textflag.h"
-#include "../../pkg/runtime/funcdata.h"
-#include "../../pkg/runtime/mgc0.h"
+#include "../../runtime/funcdata.h"
+#include "../../runtime/mgc0.h"
enum {
UNVISITED = 0,
#include <libc.h>
#include "go.h"
#include "../ld/textflag.h"
-#include "../../pkg/runtime/mgc0.h"
-#include "../../pkg/runtime/typekind.h"
+#include "../../runtime/mgc0.h"
+#include "../../runtime/typekind.h"
/*
* runtime interface and reflection data structures
// the given map type. This type is not visible to users -
// we include only enough information to generate a correct GC
// program for it.
-// Make sure this stays in sync with ../../pkg/runtime/hashmap.c!
+// Make sure this stays in sync with ../../runtime/hashmap.c!
enum {
BUCKETSIZE = 8,
MAXKEYSIZE = 128,
// the given map type. This type is not visible to users -
// we include only enough information to generate a correct GC
// program for it.
-// Make sure this stays in sync with ../../pkg/runtime/hashmap.go!
+// Make sure this stays in sync with ../../runtime/hashmap.go!
static Type*
hmap(Type *t)
{
// bptr *Bucket
// other [4]uintptr
// }
- // must match ../../pkg/runtime/hashmap.c:hash_iter.
+ // must match ../../runtime/hashmap.c:hash_iter.
field[0] = typ(TFIELD);
field[0]->type = ptrto(t->down);
field[0]->sym = mal(sizeof(Sym));
/*
* uncommonType
- * ../../pkg/runtime/type.go:/uncommonType
+ * ../../runtime/type.go:/uncommonType
*/
static int
dextratype(Sym *sym, int off, Type *t, int ptroff)
// methods
for(a=m; a; a=a->link) {
// method
- // ../../pkg/runtime/type.go:/method
+ // ../../runtime/type.go:/method
ot = dgostringptr(s, ot, a->name);
ot = dgopkgpath(s, ot, a->pkg);
ot = dsymptr(s, ot, dtypesym(a->mtype), 0);
/*
* commonType
- * ../../pkg/runtime/type.go:/commonType
+ * ../../runtime/type.go:/commonType
*/
static int
dcommontype(Sym *s, int ot, Type *t)
case TARRAY:
if(t->bound >= 0) {
- // ../../pkg/runtime/type.go:/ArrayType
+ // ../../runtime/type.go:/ArrayType
s1 = dtypesym(t->type);
t2 = typ(TARRAY);
t2->type = t->type;
ot = dsymptr(s, ot, s2, 0);
ot = duintptr(s, ot, t->bound);
} else {
- // ../../pkg/runtime/type.go:/SliceType
+ // ../../runtime/type.go:/SliceType
s1 = dtypesym(t->type);
ot = dcommontype(s, ot, t);
xt = ot - 3*widthptr;
break;
case TCHAN:
- // ../../pkg/runtime/type.go:/ChanType
+ // ../../runtime/type.go:/ChanType
s1 = dtypesym(t->type);
ot = dcommontype(s, ot, t);
xt = ot - 3*widthptr;
n++;
}
- // ../../pkg/runtime/type.go:/InterfaceType
+ // ../../runtime/type.go:/InterfaceType
ot = dcommontype(s, ot, t);
xt = ot - 3*widthptr;
ot = dsymptr(s, ot, s, ot+widthptr+2*widthint);
ot = duintxx(s, ot, n, widthint);
ot = duintxx(s, ot, n, widthint);
for(a=m; a; a=a->link) {
- // ../../pkg/runtime/type.go:/imethod
+ // ../../runtime/type.go:/imethod
ot = dgostringptr(s, ot, a->name);
ot = dgopkgpath(s, ot, a->pkg);
ot = dsymptr(s, ot, dtypesym(a->type), 0);
break;
case TMAP:
- // ../../pkg/runtime/type.go:/MapType
+ // ../../runtime/type.go:/MapType
s1 = dtypesym(t->down);
s2 = dtypesym(t->type);
s3 = dtypesym(mapbucket(t));
case TPTR32:
case TPTR64:
if(t->type->etype == TANY) {
- // ../../pkg/runtime/type.go:/UnsafePointerType
+ // ../../runtime/type.go:/UnsafePointerType
ot = dcommontype(s, ot, t);
break;
}
- // ../../pkg/runtime/type.go:/PtrType
+ // ../../runtime/type.go:/PtrType
s1 = dtypesym(t->type);
ot = dcommontype(s, ot, t);
xt = ot - 3*widthptr;
break;
case TSTRUCT:
- // ../../pkg/runtime/type.go:/StructType
+ // ../../runtime/type.go:/StructType
// for security, only the exported fields.
n = 0;
for(t1=t->type; t1!=T; t1=t1->down) {
ot = duintxx(s, ot, n, widthint);
ot = duintxx(s, ot, n, widthint);
for(t1=t->type; t1!=T; t1=t1->down) {
- // ../../pkg/runtime/type.go:/structField
+ // ../../runtime/type.go:/structField
if(t1->sym && !t1->embedded) {
ot = dgostringptr(s, ot, t1->sym->name);
if(exportname(t1->sym->name))
dsymptr(eqfunc, 0, eq, 0);
ggloblsym(eqfunc, widthptr, DUPOK|RODATA);
- // ../../pkg/runtime/alg.go:/typeAlg
+ // ../../runtime/alg.go:/typeAlg
ot = 0;
ot = dsymptr(s, ot, hashfunc, 0);
ot = dsymptr(s, ot, eqfunc, 0);
lineno = lno;
}
-// Keep in sync with src/pkg/runtime/chan.h.
+// Keep in sync with src/runtime/chan.h.
static Type*
selecttype(int32 size)
{
* users if we escape that as little as possible.
*
* If you edit this, edit ../ld/lib.c:/^pathtoprefix too.
- * If you edit this, edit ../../pkg/debug/goobj/read.go:/importPathToPrefix too.
+ * If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
*/
static char*
pathtoprefix(char *s)
walkexpr(&r->right, init);
t = r->left->type;
p = nil;
- if(t->type->width <= 128) { // Check ../../pkg/runtime/hashmap.c:MAXVALUESIZE before changing.
+ if(t->type->width <= 128) { // Check ../../runtime/hashmap.c:MAXVALUESIZE before changing.
switch(simsimtype(t->down)) {
case TINT32:
case TUINT32:
t = n->left->type;
p = nil;
- if(t->type->width <= 128) { // Check ../../pkg/runtime/hashmap.c:MAXVALUESIZE before changing.
+ if(t->type->width <= 128) { // Check ../../runtime/hashmap.c:MAXVALUESIZE before changing.
switch(simsimtype(t->down)) {
case TINT32:
case TUINT32:
)
var (
- goroot = filepath.Clean(runtime.GOROOT())
- gobin = os.Getenv("GOBIN")
- gorootBin = filepath.Join(goroot, "bin")
- gorootSrcPkg = filepath.Join(goroot, "src/pkg")
- gorootPkg = filepath.Join(goroot, "pkg")
- gorootSrc = filepath.Join(goroot, "src")
+ goroot = filepath.Clean(runtime.GOROOT())
+ gobin = os.Getenv("GOBIN")
+ gorootBin = filepath.Join(goroot, "bin")
+ gorootPkg = filepath.Join(goroot, "pkg")
+ gorootSrc = filepath.Join(goroot, "src")
)
func (b *builder) init() {
// the source directory for the package that has failed to build.
// showOutput rewrites mentions of dir with a relative path to dir
// when the relative path is shorter. This is usually more pleasant.
-// For example, if fmt doesn't compile and we are in src/pkg/html,
+// For example, if fmt doesn't compile and we are in src/html,
// the output is
//
// $ go build
//
// $ go build
// # fmt
-// /usr/gopher/go/src/pkg/fmt/print.go:1090: undefined: asdf
+// /usr/gopher/go/src/fmt/print.go:1090: undefined: asdf
// $
//
// showOutput also replaces references to the work directory with $WORK.
})
for _, src := range buildContext.SrcDirs() {
- if pattern == "std" && src != gorootSrcPkg {
+ if pattern == "std" && src != gorootSrc {
continue
}
src = filepath.Clean(src) + string(filepath.Separator)
// The initial case is not Cleaned, though, so we do this explicitly.
//
// This converts a path like "./io/" to "io". Without this step, running
- // "cd $GOROOT/src/pkg; go list ./io/..." would incorrectly skip the io
+ // "cd $GOROOT/src; go list ./io/..." would incorrectly skip the io
// package, because prepending the prefix "./" to the unclean path would
// result in "././io", and match("././io") returns false.
path = filepath.Clean(path)
}
func makeImportValid(r rune) rune {
- // Should match Go spec, compilers, and ../../pkg/go/parser/parser.go:/isValidImport.
+ // Should match Go spec, compilers, and ../../go/parser/parser.go:/isValidImport.
const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
return '_'
arg = sub
}
}
- if strings.HasPrefix(arg, "cmd/") {
+ if strings.HasPrefix(arg, "cmd/") && !strings.Contains(arg[4:], "/") {
if p := cmdCache[arg]; p != nil {
return p
}
stk.push(arg)
defer stk.pop()
- if strings.Contains(arg[4:], "/") {
- p := &Package{
- Error: &PackageError{
- ImportStack: stk.copy(),
- Err: fmt.Sprintf("invalid import path: cmd/... is reserved for Go commands"),
- hard: true,
- },
- }
- return p
- }
-
bp, err := buildContext.ImportDir(filepath.Join(gorootSrc, arg), 0)
bp.ImportPath = arg
bp.Goroot = true
# Test that without GOPATH set, go get should fail
TEST without GOPATH, go get fails
d=$(mktemp -d -t testgoXXX)
-mkdir -p $d/src/pkg
+mkdir -p $d/src
if GOPATH= GOROOT=$d ./testgo get -d code.google.com/p/go.codereview/cmd/hgpatch ; then
echo 'go get code.google.com/p/go.codereview/cmd/hgpatch should not succeed with $GOPATH unset'
ok=false
# Test that with GOPATH=$GOROOT, go get should fail
TEST with GOPATH=GOROOT, go get fails
d=$(mktemp -d -t testgoXXX)
-mkdir -p $d/src/pkg
+mkdir -p $d/src
if GOPATH=$d GOROOT=$d ./testgo get -d code.google.com/p/go.codereview/cmd/hgpatch ; then
echo 'go get code.google.com/p/go.codereview/cmd/hgpatch should not succeed with GOPATH=$GOROOT'
ok=false
# The math in root1 is not "math" because the standard math is.
cdir=$(./testgo list -f '({{.ImportPath}}) ({{.ConflictDir}})' ./testdata/shadow/root1/src/math)
-if [ "$cdir" != "(_$(pwd)/testdata/shadow/root1/src/math) ($GOROOT/src/pkg/math)" ]; then
+if [ "$cdir" != "(_$(pwd)/testdata/shadow/root1/src/math) ($GOROOT/src/math)" ]; then
echo shadowed math is not shadowed: "$cdir"
ok=false
fi
To convert the package tree from explicit slice upper bounds to implicit ones:
- gofmt -r 'α[β:len(α)] -> α[β:]' -w $GOROOT/src/pkg
+ gofmt -r 'α[β:len(α)] -> α[β:]' -w $GOROOT/src
The simplify command
#include "../ld/elf.h"
#include "../ld/macho.h"
#include "../ld/pe.h"
-#include "../../pkg/runtime/mgc0.h"
+#include "../../runtime/mgc0.h"
void dynreloc(void);
#include "l.h"
#include "lib.h"
-#include "../../pkg/runtime/typekind.h"
+#include "../../runtime/typekind.h"
// Decoding the type.* symbols. This has to be in sync with
-// ../../pkg/runtime/type.go, or more specificaly, with what
+// ../../runtime/type.go, or more specificaly, with what
// ../gc/reflect.c stuffs in these.
static Reloc*
#include "../ld/elf.h"
#include "../ld/macho.h"
#include "../ld/pe.h"
-#include "../../pkg/runtime/typekind.h"
+#include "../../runtime/typekind.h"
/*
* Offsets and sizes of the debug_* sections in the cout file.
#include "lib.h"
#include "../ld/elf.h"
#include "../ld/dwarf.h"
-#include "../../pkg/runtime/stack.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/stack.h"
+#include "../../runtime/funcdata.h"
#include <ar.h>
#if !(defined(_WIN32) || defined(PLAN9))
* escaping are %, ., and ", but we escape all control characters too.
*
* If you edit this, edit ../gc/subr.c:/^pathtoprefix too.
- * If you edit this, edit ../../pkg/debug/goobj/read.go:/importPathToPrefix too.
+ * If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
*/
static char*
pathtoprefix(char *s)
#include "l.h"
#include "lib.h"
-#include "../../pkg/runtime/funcdata.h"
+#include "../../runtime/funcdata.h"
static void
addvarint(Pcdata *d, uint32 val)
"plan9obj/testdata/386-plan9-exec",
}
for _, f := range testfiles {
- exepath := filepath.Join(runtime.GOROOT(), "src", "pkg", "debug", f)
+ exepath := filepath.Join(runtime.GOROOT(), "src", "debug", f)
cmd := exec.Command(testnmpath, exepath)
out, err := cmd.CombinedOutput()
if err != nil {
#include <bio.h>
#include <link.h>
#include "../cmd/5l/5.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
typedef struct Optab Optab;
typedef struct Oprang Oprang;
#include <bio.h>
#include <link.h>
#include "../cmd/6l/6.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
enum
{
#include <bio.h>
#include <link.h>
#include "../cmd/8l/8.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
enum
{
#include <bio.h>
#include <link.h>
#include "../cmd/5l/5.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
static Prog zprg = {
.as = AGOK,
#include <bio.h>
#include <link.h>
#include "../cmd/6l/6.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
static Prog zprg = {
.back = 2,
#include <bio.h>
#include <link.h>
#include "../cmd/8l/8.out.h"
-#include "../pkg/runtime/stack.h"
+#include "../runtime/stack.h"
static Prog zprg = {
.back = 2,
case Hdarwin:
/*
* OS X system constants - offset from 0(GS) to our TLS.
- * Explained in ../../pkg/runtime/cgo/gcc_darwin_*.c.
+ * Explained in ../../runtime/cgo/gcc_darwin_*.c.
*/
switch(ctxt->arch->thechar) {
default:
fi
# Clean old generated file that will cause problems in the build.
-rm -f ./pkg/runtime/runtime_defs.go
+rm -f ./runtime/runtime_defs.go
# Finally! Run the build.
../include/plan9/mklibc.rc > ../include/plan9/libc_plan9.h
# Clean old generated file that will cause problems in the build.
-rm -f ./pkg/runtime/runtime_defs.go
+rm -f ./runtime/runtime_defs.go
# Determine the host compiler toolchain.
eval `{grep '^(CC|LD|O)=' /$objtype/mkfile}
if p == "" || p == ctxt.GOROOT {
// Empty paths are uninteresting.
// If the path is the GOROOT, ignore it.
- // People sometimes set GOPATH=$GOROOT, which is useless
- // but would cause us to find packages with import paths
- // like "pkg/math".
+ // People sometimes set GOPATH=$GOROOT.
// Do not get confused by this common mistake.
continue
}
func (ctxt *Context) SrcDirs() []string {
var all []string
if ctxt.GOROOT != "" {
- dir := ctxt.joinPath(ctxt.GOROOT, "src", "pkg")
+ dir := ctxt.joinPath(ctxt.GOROOT, "src")
if ctxt.isDir(dir) {
all = append(all, dir)
}
}
// Determine canonical import path, if any.
if ctxt.GOROOT != "" {
- root := ctxt.joinPath(ctxt.GOROOT, "src", "pkg")
+ root := ctxt.joinPath(ctxt.GOROOT, "src")
if sub, ok := ctxt.hasSubdir(root, p.Dir); ok {
p.Goroot = true
p.ImportPath = sub
// but check that using it wouldn't find something
// else first.
if ctxt.GOROOT != "" {
- if dir := ctxt.joinPath(ctxt.GOROOT, "src", "pkg", sub); ctxt.isDir(dir) {
+ if dir := ctxt.joinPath(ctxt.GOROOT, "src", sub); ctxt.isDir(dir) {
p.ConflictDir = dir
goto Found
}
// Determine directory from import path.
if ctxt.GOROOT != "" {
- var dir string
- if strings.HasPrefix(path, "cmd/") {
- dir = ctxt.joinPath(ctxt.GOROOT, "src", path)
- } else {
- dir = ctxt.joinPath(ctxt.GOROOT, "src", "pkg", path)
- }
+ dir := ctxt.joinPath(ctxt.GOROOT, "src", path)
isDir := ctxt.isDir(dir)
binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga))
if isDir || binaryOnly {
Found:
if p.Root != "" {
- if p.Goroot {
- p.SrcRoot = ctxt.joinPath(p.Root, "src", "pkg")
- } else {
- p.SrcRoot = ctxt.joinPath(p.Root, "src")
- }
+ p.SrcRoot = ctxt.joinPath(p.Root, "src")
p.PkgRoot = ctxt.joinPath(p.Root, "pkg")
p.BinDir = ctxt.joinPath(p.Root, "bin")
if pkga != "" {
//
//
// Notes: Rounding mode detection omitted. The constants "mask", "shift",
-// and "bias" are found in src/pkg/math/bits.go
+// and "bias" are found in src/math/bits.go
// Sqrt returns the square root of x.
//
// localhostCert is a PEM-encoded TLS cert with SAN IPs
// "127.0.0.1" and "[::1]", expiring at the last second of 2049 (the end
// of ASN.1 time).
-// generated from src/pkg/crypto/tls:
+// generated from src/crypto/tls:
// go run generate_cert.go --rsa-bits 512 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h
var localhostCert = []byte(`-----BEGIN CERTIFICATE-----
MIIBdzCCASOgAwIBAgIBADALBgkqhkiG9w0BAQUwEjEQMA4GA1UEChMHQWNtZSBD
// localhostCert is a PEM-encoded TLS cert with SAN IPs
// "127.0.0.1" and "[::1]", expiring at the last second of 2049 (the end
// of ASN.1 time).
-// generated from src/pkg/crypto/tls:
+// generated from src/crypto/tls:
// go run generate_cert.go --rsa-bits 512 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h
var localhostCert = []byte(`-----BEGIN CERTIFICATE-----
MIIBdzCCASOgAwIBAgIBADALBgkqhkiG9w0BAQUwEjEQMA4GA1UEChMHQWNtZSBD
bitsPointer = 2
)
-// Make sure these routines stay in sync with ../../pkg/runtime/hashmap.go!
+// Make sure these routines stay in sync with ../../runtime/hashmap.go!
// These types exist only for GC, so we only fill out GC relevant info.
// Currently, that's just size and the GC program. We also fill in string
// for possible debugging use.
return cvtT2I(v.Elem(), typ)
}
-// implemented in ../pkg/runtime
+// implemented in ../runtime
func chancap(ch unsafe.Pointer) int
func chanclose(ch unsafe.Pointer)
func chanlen(ch unsafe.Pointer) int
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
-include ../../Make.dist
+include ../Make.dist
The traceback should look something like this, modulo line numbers and hex constants.
Don't worry much about the base levels, but check the ones in our own package.
- /Users/r/go/src/pkg/runtime/debug/stack_test.go:15 (0x13878)
+ /Users/r/go/src/runtime/debug/stack_test.go:15 (0x13878)
(*T).ptrmethod: return Stack()
- /Users/r/go/src/pkg/runtime/debug/stack_test.go:18 (0x138dd)
+ /Users/r/go/src/runtime/debug/stack_test.go:18 (0x138dd)
T.method: return t.ptrmethod()
- /Users/r/go/src/pkg/runtime/debug/stack_test.go:23 (0x13920)
+ /Users/r/go/src/runtime/debug/stack_test.go:23 (0x13920)
TestStack: b := T(0).method()
- /Users/r/go/src/pkg/testing/testing.go:132 (0x14a7a)
+ /Users/r/go/src/testing/testing.go:132 (0x14a7a)
tRunner: test.F(t)
- /Users/r/go/src/pkg/runtime/proc.c:145 (0xc970)
+ /Users/r/go/src/runtime/proc.c:145 (0xc970)
???: runtime·unlock(&runtime·sched);
*/
func TestStack(t *testing.T) {
n++
}
}
- frame("src/pkg/runtime/debug/stack_test.go", "\t(*T).ptrmethod: return Stack()")
- frame("src/pkg/runtime/debug/stack_test.go", "\tT.method: return t.ptrmethod()")
- frame("src/pkg/runtime/debug/stack_test.go", "\tTestStack: b := T(0).method()")
- frame("src/pkg/testing/testing.go", "")
+ frame("src/runtime/debug/stack_test.go", "\t(*T).ptrmethod: return Stack()")
+ frame("src/runtime/debug/stack_test.go", "\tT.method: return t.ptrmethod()")
+ frame("src/runtime/debug/stack_test.go", "\tTestStack: b := T(0).method()")
+ frame("src/testing/testing.go", "")
}
func check(t *testing.T, line, has string) {
tests := [...]TestCase{
{"chan recv", blockChanRecv, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ runtime\.chanrecv1\+0x[0-9,a-f]+ .*/src/pkg/runtime/chan.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanRecv\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime\.chanrecv1\+0x[0-9,a-f]+ .*/src/runtime/chan.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanRecv\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"chan send", blockChanSend, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ runtime\.chansend1\+0x[0-9,a-f]+ .*/src/pkg/runtime/chan.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanSend\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime\.chansend1\+0x[0-9,a-f]+ .*/src/runtime/chan.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanSend\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"chan close", blockChanClose, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ runtime\.chanrecv1\+0x[0-9,a-f]+ .*/src/pkg/runtime/chan.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanClose\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime\.chanrecv1\+0x[0-9,a-f]+ .*/src/runtime/chan.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockChanClose\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"select recv async", blockSelectRecvAsync, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ runtime\.selectgo\+0x[0-9,a-f]+ .*/src/pkg/runtime/select.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockSelectRecvAsync\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime\.selectgo\+0x[0-9,a-f]+ .*/src/runtime/select.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockSelectRecvAsync\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"select send sync", blockSelectSendSync, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ runtime\.selectgo\+0x[0-9,a-f]+ .*/src/pkg/runtime/select.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockSelectSendSync\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime\.selectgo\+0x[0-9,a-f]+ .*/src/runtime/select.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockSelectSendSync\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"mutex", blockMutex, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ sync\.\(\*Mutex\)\.Lock\+0x[0-9,a-f]+ .*/src/pkg/sync/mutex\.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockMutex\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ sync\.\(\*Mutex\)\.Lock\+0x[0-9,a-f]+ .*/src/sync/mutex\.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockMutex\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
{"cond", blockCond, `
[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-# 0x[0-9,a-f]+ sync\.\(\*Cond\)\.Wait\+0x[0-9,a-f]+ .*/src/pkg/sync/cond\.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.blockCond\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
-# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ sync\.\(\*Cond\)\.Wait\+0x[0-9,a-f]+ .*/src/sync/cond\.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.blockCond\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
+# 0x[0-9,a-f]+ runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+ .*/src/runtime/pprof/pprof_test.go:[0-9]+
`},
}
// This file merely ensures that we link in runtime/cgo in race build,
// this is turn ensures that runtime uses pthread_create to create threads.
// The prebuilt race runtime lives in race_GOOS_GOARCH.syso.
-// Calls to the runtime are done directly from src/pkg/runtime/race.c.
+// Calls to the runtime are done directly from src/runtime/race.c.
// void __race_unused_func(void);
import "C"
}
defer os.RemoveAll(dir)
- out, err := exec.Command("go", "build", "-o", dir+"/hello", "../../../test/helloworld.go").CombinedOutput()
+ out, err := exec.Command("go", "build", "-o", dir+"/hello", "../../test/helloworld.go").CombinedOutput()
if err != nil {
t.Fatalf("building hello world: %v\n%s", err, out)
}
// +build race
// This file is here only to allow external functions.
-// The operations are implemented in src/pkg/runtime/race_amd64.s
+// The operations are implemented in src/runtime/race_amd64.s
var t0 time.Time
var numGC uint32
var pauseTotalNs uint64
- pkgroot := runtime.GOROOT() + "/src/pkg/"
+ pkgroot := runtime.GOROOT() + "/src/"
for pass := 0; pass < 2; pass++ {
// Once the heap is grown to full size, reset counters.
// This hides the start-up pauses, which are much smaller
}
func stressParseGo() {
- pkgroot := runtime.GOROOT() + "/src/pkg/"
+ pkgroot := runtime.GOROOT() + "/src/"
for {
m := make(map[string]map[string]*ast.Package)
for _, pkg := range packages {