Go内部实现 — Go语言学习园地博客

汇编和Plan9汇编

五 312013

最近在研究 Go 的源代码（阅读后的代码注释放在了github上:http://github.com/polaris1119/go_src_comment），由于不少底层代码是用汇编写的，而且是 Plan9 的汇编，因此重新看了一些汇编和 Plan9 汇编的知识。在这里做一个总结、备忘。

一、资源

1、指令查询：

http://68k.hax.com/

2、命令查询

http://plan9.bell-labs.com/magic/man2html/1/8a

3、LEA 和 MOV

LEA：操作地址；
MOV：操作数据

如：
LEAQ 8(SP), SI // argv 把 8(SP)地址放入 SI 寄存器中
MOVQ 0(SP), DI // argc 把0(SP)内容放入 DI 寄存器中

4、对外部数据的引用需要用到伪寄存器 PC (the virtual program counter) or SB (the ‘static base’ register)。PC counts instructions, not bytes of data，即 2(PC)是跳过一条指令。

5、http://plan9.bell-labs.com/plan9/

http://plan9.bell-labs.com/sys/doc/

plan9 各种文档，html/ps/pdf 格式供下载

更新日志

1、2013-05-31 开始写

一、简介

cmd/dist是生成Go distribution的引导工具。它负责构建C程序（像Go编译器）和初始化Go工具的拷贝（即go_bootstrap）。

dist本身是用C语言写的。所有和C库，甚至和C标准库的交互，都通过一个系统相关的文件封装起来，以方便移植，如：plan9.c、unix.c和windows.c等。通过这个可移植层提供功能，供其他文件使用。在这个可移植层中，为了避免和现有函数混淆，相同功能的函数带有前缀：x。例如：xprintf是printf的可移植版本。

到目前为止，dist中大部分普通数据类型是字符串或字符串数组。然而，dist中使用两个命名的数据结构：Buf和Vec，保存它们拥有的所有数据，而不是使用char*和char**。Buf相当于Go中的[]byte，Vec相当于Go中的[]string。对Buf的操作函数以b开头；对Vec的操作函数以v开头。

二、文件概览

a.h arg.h arm.c buf.c build.c buildgc.c buildruntime.c goc2c.c main.c plan9.c README unix.c windows.c

注：go1.0.3源码中没有plan9.c文件，tips中有该文件。

1、README

学习前看README。本文简介部分基本来自该文件。

2、a.h

定义了一些类型，比如简介中提到的Buf和Vec；声明了dist中所有.c文件中的函数

Buf和Vec的结构：

`1`	`// A Buf is a byte buffer, like Go's []byte.`

`2`	`typedef` `struct` `Buf Buf;`

`3`	`struct` `Buf`

4 {

`5`	`char` `*p;`

`6`	`int` `len;`

`7`	`int` `cap;`

8 };

9

`10`	`// A Vec is a string vector, like Go's []string.`

`11`	`typedef` `struct` `Vec Vec;`

`12`	`struct` `Vec`

13 {

`14`	`char` `**p;`

`15`	`int` `len;`

`16`	`int` `cap;`

17 };

可以看到，结构很像Go中slice的内部定义

3、arg.h

该文件中声明了一个变量和定义了五个宏，它和libc.h中的定义是一样的。源码中大量使用了这些宏，特别是ARGBEGIN和ARGEND。通过源码，可以知道，ARGBEGIN宏其实就是循环遍历命令行参数（不包括dist和其子命令），参数要求以-开头展开如下（以build.c中的cmdclean为例）：

`1`	`for((argv0?0:(argv0=*argv)),argv++,argc--; argv[0] && argv[0][0]=='-'` `&& argv[0][1]; argc--, argv++) {`

`2`	`char` `_args, _argt;`

`3`	`char` `_argc;`

`4`	`_args = &argv[0][1];`

`5`	`if(_args[0]=='-'` `&& _args[1]==0){`

6 argc--;

7 argv++;

8 break;

9 }

`10`	`_argc = 0;`

`11`	`while((_argc = *_args++) != 0)`

`12`	`switch(_argc){`

`13`	`case` `'v':`

`14`	`vflag++;`

15 break;

`16`	`default:`

`17`	`usage();`

18 }

`19`	`_argt=0;`

`20`	`USED(_argt);`

`21`	`USED(_argc);`

`22`	`USED(_args);`

23 }

`24`	`USED(argv);`

`25`	`USED(argc);`

4、plan9.c/unix.c/windows.c/main.c

感觉上main.c是dist的入口。实际上特定操作系统的文件才包含了main入口函数。main.c中只是一个“伪入口”函数:xmain

如简介中所说，特定操作系统的文件封装了特定操作系统的一些函数，以方便移植。

5、buf.c

提供了对Buf和Vec的操作

6、build.c

初始化对dist的任何调用，即运行dist时需要调用build.c中的函数执行初始化

7、buildgc.c

构建cmd/gc时的辅助文件

8、buildruntime.c

构建pkg/runtime时的辅助文件

9、goc2c.c

将.goc文件转为.c文件。一个.goc文件是一个组合体：包含Go代码和C代码。注意：goc文件和cgo是不一样的。

三、关键源码解读

以Linux操作系统为例，Windows版本基本一样，只是系统调用等不一样，区别就是unix.c和windows.c的不同。

1、执行流程

1）在unix.c中的main入口函数中，首先设置了gohostos和gohostarch，这是本机的操作系统和系统架构。main中会调用build.c中的init和main.c中的xmain

2）build.c中init函数负责全局状态的初始化，如：goroot、goos、goarch等

3）main.c中xmain函数是main的可移植版本，即特定平台的main将入口转发到xmain中

4）根据传递给dist的具体命令执行相应的函数

2、dist的功能（命令）

在main.c中定义了可用的命令：

`1`	`// cmdtab records the available commands.`

`2`	`static` `struct` `{`

`3`	`char` `*name;`

`4`	`void` `(f)(int,` `char*);`

`5`	`} cmdtab[] = {`

`6`	`{"banner", cmdbanner},`

`7`	`{"bootstrap", cmdbootstrap},`

`8`	`{"clean", cmdclean},`

`9`	`{"env", cmdenv},`

`10`	`{"install", cmdinstall},`

`11`	`{"version", cmdversion},`

12 };

这些命令对应的f是在build.c中实现的。

1）banner->cmdbanner

输出Go安装完成的提示。

提示语句类似：

---Installed Go for linux/amd64 in /home/polaris/goInstalled commands in /home/polaris/go/bin*** You need to add /home/polaris/go/bin to your PATH.

其中，如果go/bin已经在PATH中，则不会提示最后一句。

2）bootstrap->cmdbootstrap

这是一个重要的命令，通过这个命令生成Go引导工具：go_bootstrap，其实就是go命令，以及其他工具。
该命令首先会执行build.c中的setup函数，初始化Go目录树，为构建Go做准备，初始化工作包括：创建bin目录、pkg目录及其子目录（如obj/tool等），同时做一些必要的清除工作。

接着为本机操作系统和架构构建Go，具体构建顺序在build.c中的buildorder数组中定义了，这个顺序在安装Go的过程中的输出可以看到。实际的构建是通过build.c中的install函数执行的。

install函数比较长，做的事情就是：根据传给它的源码目录（这是按照buildorder中来的），用gcc或其他编译器（如6a/6c/6g）编译源码，生成pkg/obj、pkg/tool和pkg中的C库、命令和Go包。注意，这个时候tool中有一个go_bootstrap，这个其实就是go命令。（可以通过在make.bash中的./cmd/dist/dist bootstrap $buildall -v后面加上exit 0来看到这个中间过程）

总结一下这一步所做的事情：
①没有构建全部的工具（从buildorder中也可以看出），构建了关键的工具go_bootstrap
②构建了C库（在pkg/obj/下）
③构建了编译器等（[568]a/c/g/l）
④将runtime包中的goc文件转为c文件
⑤构建一些Go包（标准库），之所以构建这些包，是因为cmd/go命令是用Go语言写的，它依赖这些包。但实际上接下来会将这些构建好的Go包删除，这里实际上产生一些文件（要产生的文件定义在gentab结构中），产生这些文件的目的是使runtime包能够通过go命令统一编译。
go_bootstrap是通过[568]g构建的

关于产生的文件，这里详细解释一下：
在build.c中的deptab结构数组中定义了库和工具的依赖关系，其中pkg/runtime包依赖一些文件：

`1`	`{"pkg/runtime", {`

`2`	`"zasm_$GOOS_$GOARCH.h",`

`3`	`"zgoarch_$GOARCH.go",`

`4`	`"zgoos_$GOOS.go",`

`5`	`"zruntime_defs_$GOOS_$GOARCH.go",`

`6`	`"zversion.go",`

7 }}

这些文件是通过该过程动态生成的，具体怎么生成，在gentab结构数组中有定义，

`1`	`static` `struct` `{`

`2`	`char` `*nameprefix;`

`3`	`void` `(gen)(char,` `char*);`

`4`	`} gentab[] = {`

`5`	`// 以下两个是编译器依赖，在buildgc.c中实现`

`6`	`{"opnames.h", gcopnames},` `// gc编译器依赖，在gcopnames函数中通过cmd/gc/go.h生成`

`7`	`{"enam.c", mkenam},` `// [568]c/g/l依赖，在mkenam函数中通过对应的[568].out.h文件生成`

`8`	`// 以下是runtime包依赖的，在buildruntime.c中实现`

`9`	`{"zasm_", mkzasm},` `// 汇编文件需要用到`

`10`	`{"zgoarch_", mkzgoarch},` `// 当前主机的架构`

`11`	`{"zgoos_", mkzgoos},` `// 当前主机的操作系统`

`12`	`{"zruntime_defs_", mkzruntimedefs},` `// 数据结构定义（Go版），和runtime.h中一些结构定义类似。`

`13`	`// 从runtimedefs结构数组中的文件提取。`

`14`	`{"zversion.go", mkzversion},` `// 定义GOROOT和GoVersion，分别是goroot_final和goversion`

15 };

可见，安装并不需要配置GOOS、GOARCH之类的环境变量，在unix.c或windows.c中会判断出当前环境

对于交叉编译，第一次准备目标环境时，会install(“pkg/runtime”)

另外，该过程会将runtime.h和cgocall.h拷贝到了pkg/$GOOS_$GOARCH目录下，这是给cgo编译的时候使用的。

关于make.bash中接下来通过go_bootstrap安装其他命令和包的过程，在后续文章中分析。

3）clean->cmdclean

删除临时对象。clean -i会将安装了的对象也删除（即pkg中的.a文件）

4）env->cmdenv

输出默认的环境变量。env -p会输出PATH环境变量。

默认的输出格式是：

GOROOT="/home/polaris/go"GOBIN="/home/polaris/go/bin"GOARCH="amd64"GOOS="linux"GOHOSTARCH="amd64"GOHOSTOS="linux"GOTOOLDIR="/home/polaris/go/pkg/tool/linux_amd64"GOCHAR="6"     // 5、6、8啥意思大家懂的

而env -w是：

set GOROOT=/home/polaris/goset GOBIN=/home/polaris/go/binset GOARCH=amd64set GOOS=linuxset GOHOSTARCH=amd64set GOHOSTOS=linuxset GOTOOLDIR=/home/polaris/go/pkg/tool/linux_amd64set GOCHAR=6

在make.bash中，执行eval $(./cmd/dist/dist env -p)，就相当于在make.bash中定义了上面的变量，包括PATH。

由此可见，源码安装的时候，并不需要设置GOROOT等环境变量。当然，安装完后必须的环境变量还是需要设置的，要不然会提示go命令找不到，因为这里设置的环境变量只是临时用的。

5）install->cmdinstall

通过build.c中install方法安装某个包，比如：

go tool dist install pkg/runtime

注意这种方式和go install的区别

6）version->cmdversion

输出当前Go版本信息。版本信息是通过build.c中的findgoversion函数得到的。

四、总结

从上面的分析可以看出，在Go中，通过gcc编译出dist后，由dist负责其他编译器等的编译，包括各种环境，这样，Go包中的.s、.c、.g都由自身的编译器[568]s/c/g/、链接器[568]l和打包工具pack 负责编译、链接和打包，完全自给自足。

分析源码安装Go的过程（初稿）

Go内部实现 4 条评论 ?

一 012013

安装Go语言，建议通过源码安装。通过源码安装Go，一般只需要安装一个GCC编译器就可以了。（Windows下是安装MinGW）。该文分析通过源码安装Go语言的过程。

一、分析安装脚本

在《探究Go中各个目录的功能》一文中提到了几个脚本，以及它们的作用。现在来分析这些脚本都做了些什么。（以linux下为例，Windows对应的脚本类似）

1、all.bash

`1`	`set` `-e`

`2`	`if` `[ ! -f` `make.bash` `];` `then`

`3`	`echo` `'all.bash must be run from $GOROOT/src'` `1>&2`

`4`	`exit` `1`

5 fi

`6`	`OLDPATH="$PATH"`

`7`	`. ./make.bash` `--no-banner`

`8`	`bash` `run.bash` `--no-rebuild`

`9`	`PATH="$OLDPATH"`

`10`	`$GOTOOLDIR/dist banner` `# print build info`

说明：

1）set -e 当脚本中某个命令返回非零退出状态时，脚本退出
2）if语句是要求all.bash必须在make.bash所在的目录运行（也就是$GOROOT/src）
3）OLDPATH=”$PATH” 保存当前PATH
4）执行make.bash并传递–no-banner参数
5）执行run.bash并传递–no-rebuild参数
6）执行dist工具并传递 banner参数，打印build信息

2、make.bash

在make.bash中，有一些环境变量，执行make.bash过程中会用到。

①GOROOT_FINAL：最终被设置的Go root，在编译过程中，默认是Go tree的位置。

②GOHOSTARCH：为主机工具（编译器和二进制文件）指定体系结构。这种类型的二进制文件在当前系统必须是可执行的，因此设置这个环境变量的目前唯一常见原因是在AMD64机器上设置GOHOSTARCH=386。（也就是说，在ADM64上可以运行386的可执行文件）

③GO_GCFLAGS：当构建包和命令时可以通过该环境变量附带上5g/6g/8g的参数

④GO_LDFLAGS：当构建包和命令时可以通过该环境变量附带上5l/6l/8l的参数

⑤CGO_ENABLED：在构建过程中控制cgo的使用。当设置为1，在构建时，会包含所有cgo相关的文件，如带有”cgo”编译指令的.c和.go文件。当设置为0，则忽略它们（即禁用CGO）

在文件开头是一些检查：比如是否在Windows下运行了make.bash，ld的版本等。

make.bash中接下来主要的工作（也就是开始构建）：

1）构建 C 引导工具 —— cmd/dist

这里首先会export GOROOT环境变量，它的值就是go源码所在路径，可见，源码安装之前并不要求一定要设置GOROOT。

这里学习一个shell脚本知识

GOROOT_FINAL=”${GOROOT_FINAL:-$GOROOT}”
这叫做参数替换，形式如下：
${parameter-default},${parameter:-default}
意思是：如果 parameter 没被 set，那么就使用 default。这两种形式大部分时候是相同的。区别是：当parameter被设置了且为空，则第一种不能输出默认值，而第二种可以。

所以，GOROOT_FINAL=”${GOROOT_FINAL:-$GOROOT}”的意思就是，如果GOROOT_FINAL没设置，则GOROOT_FINAL=$GOROOT

通过gcc编译cmd/dist

2）构建编译器和Go引导工具

首先通过执行dist设置需要的环境变量
eval $(./cmd/dist/dist env -p)

接着构建Go引导工具：go_bootstrap，以及编译器等

3）构建包和命令工具

这是通过go_bootstrap做的

3、run.bash

该脚本是一个测试脚本，运行标准库中的测试用例。默认情况下会重新构建go包和工具。由于make.bash会做构建的工作，all.bash中执行run.bash时，传递了–no-rebuild

二、源码安装说明

源码安装Go语言，一般只需要执行./all.bash就可以了。（Windows上执行all.bat）

根据上面的分析，这样会运行测试脚本。如果想更快的安装Go，可以直接运行make.bash（Windows上是make.bat）

整个安装过程大概如下：

# Building C bootstrap tool.
cmd/dist
# Building compilers and Go bootstrap tool for host, linux/amd64.
lib9
libbio
libmach
misc/pprof
……
pkg/text/template/parse
pkg/text/template
pkg/go/doc
pkg/go/build
cmd/go
# Building packages and commands for linux/amd64.
runtime
errors
sync/atomic
sync
io
……
testing
testing/iotest
testing/quick
# Testing packages.
ok cmd/api 0.031s
cmd/cgo [no test files]
ok cmd/fix 3.558s
ok cmd/go 0.022s
……
unsafe [no test files]
real 3m6.056s
user 2m29.517s
sys 0m25.134s
# GOMAXPROCS=2 runtime -cpu=1,2,4
ok runtime 6.605s
# sync -cpu=10
ok sync 0.428s
# Testing race detector.
ok flag 1.044s
# ../misc/cgo/stdio
# ../misc/cgo/life
# ../misc/cgo/test
scatter = 0×430490
hello from C
PASS
ok _/home/polaris/go/misc/cgo/test 1.137s
# ../misc/cgo/testso
# ../doc/progs
real 0m19.110s
user 0m15.341s
sys 0m2.904s
# ../doc/articles/wiki
run.bash: 行 92: make: 未找到命令
PASS
# ../doc/codewalk
# ../misc/dashboard/builder ../misc/goplay
# ../test/bench/shootout
fasta
reverse-complement
nbody
binary-tree
binary-tree-freelist
fannkuch
fannkuch-parallel
regex-dna
regex-dna-parallel
spectral-norm
k-nucleotide
k-nucleotide-parallel
mandelbrot
meteor-contest
pidigits
threadring
chameneosredux
# ../test/bench/go1
ok _/home/polaris/go/test/bench/go1 4.942s
# ../test
real 1m38.036s
user 1m14.701s
sys 0m16.645s
# Checking API compatibility.
+pkg crypto/x509, const PEMCipher3DES PEMCipher
+pkg crypto/x509, const PEMCipherAES128 PEMCipher
+pkg crypto/x509, const PEMCipherAES192 PEMCipher
+pkg crypto/x509, const PEMCipherAES256 PEMCipher
+pkg crypto/x509, const PEMCipherDES PEMCipher
+pkg crypto/x509, func EncryptPEMBlock(io.Reader, string, []byte, []byte, PEMCipher)
……
+pkg reflect, func SliceOf(Type) Type
+pkg regexp, method (*Regexp) Split(string, int) []string
~pkg text/template/parse, type DotNode bool
~pkg text/template/parse, type Node interface { Copy, String, Type }
ALL TESTS PASSED
—
Installed Go for linux/amd64 in /home/polaris/go
Installed commands in /home/polaris/go/bin
*** You need to add /home/polaris/go/bin to your PATH.

三、带中文注释的脚本

以下是我加上了注释的make.bash脚本（关键部分）

`1`	`echo` `'# Building C bootstrap tool.'`

`2`	`echo` `cmd/dist`

`3`	`# export当前Go源码所在跟目录为GOROOT`

`4`	`export` `GOROOT="$(cd .. && pwd)"`

`5`	`# 如果GOROOT_FINAL没有设置，则使用$GOROOT的值当做GOROOT_FINAL`

`6`	`GOROOT_FINAL="${GOROOT_FINAL:-$GOROOT}"`

`7`	`DEFGOROOT='-DGOROOT_FINAL="'"$GOROOT_FINAL"'"'`

8

`9`	`# 如果在amd64机子上编译Go本身为32位，可以设置 $GOHOSTARCH=386。不建议这么做`

`10`	`mflag=""`

`11`	`case` `"$GOHOSTARCH"` `in`

`12`	`386) mflag=-m32;;`

`13`	`amd64) mflag=-m64;;`

14 esac

15

`16`	`# gcc编译：编译cmd/dist下所有的c文件`

`17`	`# -m：指定处理器架构，以便进行优化（-m32、-m64）或为空（一般为空）`

`18`	`# -O：优化选项，一般为：-O2。优化得到的程序比没优化的要小，执行速度可能也有所提高`

`19`	`# -Wall：生成所有警告信息`

`20`	`# -Werror：所有警告信息都变成错误`

`21`	`# -ggdb：为gdb生成调试信息（-g是生成调试信息）`

`22`	`# -o：生成指定的输出文件`

`23`	`# -I：指定额外的文件搜索路径`

`24`	`# -D：相当于C语言中的#define GOROOT_FINAL="$GOROOT_FINAL"`

`25`	`gcc $mflag -O2 -Wall -Werror -ggdb -o cmd/dist/dist -Icmd/dist` `"$DEFGOROOT"` `cmd/dist/*.c`

26

`27`	`# 编译完 dist 工具后，运行dist。目的是设置相关环境变量`

`28`	`# 比如：$GOTOOLDIR 环境变量就是这里设置的`

`29`	`eval` `$(./cmd/dist/dist` `env` `-p)`

30 echo

31

`32`	`# 运行make.bash时传递--dist-tool参数可以仅编译dist工具`

`33`	`if` `[` `"$1"` `=` `"--dist-tool"` `];` `then`

`34`	`# Stop after building dist tool.`

`35`	`mkdir` `-p` `"$GOTOOLDIR"`

`36`	`if` `[` `"$2"` `!=` `""` `];` `then`

`37`	`cp` `cmd/dist/dist` `"$2"`

38 fi

`39`	`mv` `cmd/dist/dist` `"$GOTOOLDIR"/dist`

`40`	`exit` `0`

41 fi

42

`43`	`# 构建编译器和Go引导工具`

`44`	`# $GOHOSTOS/$GOHOSTARCH 是运行dist设置的`

`45`	`echo` `"# Building compilers and Go bootstrap tool for host, $GOHOSTOS/$GOHOSTARCH."`

`46`	`# 表示重新构建`

`47`	`buildall="-a"`

`48`	`# 传递--no-clean 表示不重新构建`

`49`	`if` `[` `"$1"` `=` `"--no-clean"` `];` `then`

`50`	`buildall=""`

51 fi

`52`	`# 构建Go引导工具`

`53`	`./cmd/dist/dist bootstrap $buildall -v` `# builds go_bootstrap`

`54`	`# Delay move of dist tool to now, because bootstrap may clear tool directory.`

`55`	`mv` `cmd/dist/dist` `"$GOTOOLDIR"/dist`

`56`	`"$GOTOOLDIR"/go_bootstrap clean -i std`

57 echo

58

`59`	`# $GOHOSTARCH 与 $GOARCH的区别：（$GOHOSTOS 与 $GOOS的区别一样）`

`60`	`# GOARCH 表示Go写出来的程序会在什么架构运行（目标操作系统）；`

`61`	`# GOHOSTARCH 表示运行make.bash这个脚本的系统架构`

`62`	`# 一般它们是相等的，只有在需要交叉编译时才会不一样。`

`63`	`if` `[` `"$GOHOSTARCH"` `!=` `"$GOARCH"` `-o` `"$GOHOSTOS"` `!=` `"$GOOS"` `];` `then`

`64`	`# 即使交叉编译，本机的Go环境还是必须得有`

`65`	`echo` `"# Building packages and commands for host, $GOHOSTOS/$GOHOSTARCH."`

`66`	`GOOS=$GOHOSTOS GOARCH=$GOHOSTARCH \`

`67`	`"$GOTOOLDIR"/go_bootstrap` `install` `-gcflags` `"$GO_GCFLAGS"` `-ldflags` `"$GO_LDFLAGS"` `-v` `std`

68 echo

69 fi

70

`71`	`echo` `"# Building packages and commands for $GOOS/$GOARCH."`

`72`	`"$GOTOOLDIR"/go_bootstrap` `install` `-gcflags` `"$GO_GCFLAGS"` `-ldflags` `"$GO_LDFLAGS"` `-v` `std`

73 echo

74

`75`	`rm` `-f` `"$GOTOOLDIR"/go_bootstrap`

76

`77`	`# 是否打印安装成功的提示信息。一般为：`

`78`	`# Installed Go for $GOOS/$GOARCH in $GOROOT`

`79`	`# Installed commands in $GOROOT/bin`

`80`	`if` `[` `"$1"` `!=` `"--no-banner"` `];` `then`

`81`	`"$GOTOOLDIR"/dist banner`

82 fi

为了方便，将带注释的脚本放在了github上：go_install_bash_comment

注：有些是根据脚本中的英文翻译的，如不明白，请看脚本的注释；如有不对，请指正！谢谢！

说明：这是初稿，很多地方还没有仔细分析。

探究GO中各个目录的功能

Go内部实现 2 条评论 ?

十二 272012

下载Go源码后，根目录结构如下：

|– AUTHORS — 文件，官方 Go语言作者列表
|– CONTRIBUTORS — 文件，第三方贡献者列表
|– LICENSE — 文件，Go语言发布授权协议
|– PATENTS — 文件，专利
|– README — 文件，README文件，大家懂的。提一下，经常有人说：Go官网打不开啊，怎么办？其实，在README中说到了这个。该文件还提到，如果通过二进制安装，需要设置GOROOT环境变量；如果你将Go放在了/usr/local/go中，则可以不设置该环境变量（Windows下是C:\go）。当然，建议不管什么时候都设置GOROOT。另外，确保$GOROOT/bin在PATH目录中。
|– VERSION — 文件，当前Go版本
|– api — 目录，包含所有API列表，方便IDE使用
|– doc — 目录，Go语言的各种文档，官网上有的，这里基本会有，这也就是为什么说可以本地搭建”官网”。这里面有不少其他资源，比如gopher图标之类的。
|– favicon.ico — 文件，官网logo
|– include — 目录，Go 基本工具依赖的库的头文件
|– lib — 目录，文档模板
|– misc — 目录，其他的一些工具，相当于大杂烩，大部分是各种编辑器的Go语言支持，还有cgo的例子等
|– robots.txt — 文件，搜索引擎robots文件
|– src — 目录，Go语言源码：基本工具（编译器等）、标准库
`– test — 目录，包含很多测试程序（并非_test.go方式的单元测试，而是包含main包的测试），包括一些fixbug测试。可以通过这个学到一些特性的使用。

下面详细介绍一些目录（可能分功能介绍）

一、api目录

|– README
|– go1.txt
`– next.txt

通过阅读README知道，go1.txt可以通过go tool api命令生成。而通过go1.txt可以做成编辑器的api自动提示，比如Vim：VimForGo
next.txt是一些将来可能加入的API

二、Go基本工具（cmd）

1、include目录

该目录包含以下文件（文件夹）

ar.h bio.h bootexec.h fmt.h libc.h mach.h plan9 u.h ureg_amd64.h ureg_arm.h ureg_x86.h utf.h

其中，plan9目录是针对Plan 9操作系统的，从里面的文件名知道，跟include跟目录下的是一个意思。

386 libc.h mach.h ureg_amd64.h ureg_arm.h ureg_x86.h （386目录下就只有一个u.h头文件）

1）u.h

根据Rob Pike在How to Use the Plan 9 C Compiler上的介绍以及文件的源码，知道u.h文件定义了一些依赖架构（architecture-dependent）的类型（这样使得该类型独立于架构，不过依赖于编译器），如用于setjmp系统调用的jmp_buf，以及类型int8、uint8等。

该文件直接来源于plan9。地址：http://code.swtch.com/plan9port/src/tip/include/u.h。所有plan9 C程序必须在开始出包含该头文件（因为其他文件引用了该文件中的类型定义）

2）ureg.h

包括：ureg_amd64.h ureg_arm.h ureg_x86.h

三种架构的定义。该文件来源于Inferno操作系统，相应的源码分别是：http://code.google.com/p/inferno-os/source/browse/utils/libmach/ureg5/6/8.h。

该文件定义了一个类型（struct）：Ureg。定义了在系统栈上寄存器的布局

在ureg_x86.h中对各个字段有注释：

`1`	`struct` `Ureg`

2 {

`3`	`uint32 di;` `/* general registers */`

`4`	`uint32 si;` `/* ... */`

`5`	`uint32 bp;` `/* ... */`

`6`	`uint32 nsp;`

`7`	`uint32 bx;` `/* ... */`

`8`	`uint32 dx;` `/* ... */`

`9`	`uint32 cx;` `/* ... */`

`10`	`uint32 ax;` `/* ... */`

`11`	`uint32 gs;` `/* data segments */`

`12`	`uint32 fs;` `/* ... */`

`13`	`uint32 es;` `/* ... */`

`14`	`uint32 ds;` `/* ... */`

`15`	`uint32 trap;` `/* trap type */`

`16`	`uint32 ecode;` `/* error code (or zero) */`

`17`	`uint32 pc;` `/* pc */`

`18`	`uint32 cs;` `/* old context */`

`19`	`uint32 flags;` `/* old flags */`

`20`	`union` `{`

`21`	`uint32 usp;`

`22`	`uint32 sp;`

23 };

`24`	`uint32 ss;` `/* old stack segment */`

25 };

3）libc.h/utf.h/fmt.h

在严格的标准C中，头文件按相关功能分组在一个单独文件中：一个头文件用于字符串处理，一个头文件用于内存管理，一个头文件用于I/O处理，没有头文件是用于系统调用的。plan9采用了不同的方式，一个C库由strings函数、内存操作函数、一些格式化IO程序，加上所有和这些相关的系统调用。为了使用这些功能，需要包含libc.h头文件。该文件从Inferno和Plan9中提取出来的。

Inferno：http://code.google.com/p/inferno-os/source/browse/include/kern.h
Plan 9：http://code.swtch.com/plan9port/src/tip/include/libc.h

该文件开头有几行注释：
/*
* Lib9 is miscellany from the Plan 9 C library that doesn’t
* fit into libutf or into libfmt, but is still missing from traditional
* Unix C libraries.
*/

在该文件中包含了utf.h和fmt.h

在Plan 9中使用nil表示指针的零值，这也就是为什么Go中采用nil了。nil的定义在libc.h中：

`1`	`#ifndef nil`

`2`	`#define nil ((void*)0)`

3 #endif

对于solaris，nil在u.h中有定义

另外，libc中声明了很多系统调用

包含了该文件之后，可以直接使用print、fprint之类的，而不需要包含标准IO库，这是因为libc.h中包含了fmt.h，而fmt.h中提供了这些print函数。当然，如果需要使用printf，得导入stdio.h

utf.h是实际上引用了src/lib9/utf/utf.h，提供了对UNICODE字符集相关操作。

题外话：

Plan 9支持的每一种CPU架构都给其一个单个字母或数字的名称：k表示SPARC，q表示Motorola Power PC 630和640，v表示MIPS，0表示little-endian MIPS，1表示Motorola 68000，2表示Motorola 68020和68040，5表示Acorn ARM 7500，6表示AMD64,7表示DEC Alpha，8表示Intel 386，9表示AMD 2900。可以看出，Go中5/6/8的由来了。
对于为什么取这样的名字，How to Use the Plan 9 C Compiler 中Heterogeneity有解释。

注意：在看源码过程中可能会看到

`1`	`ARGBEGIN{`

2 }ARGEND

这是在libc.h中定义的宏。这是一些处理命令行参数的宏。其他宏还有：

1 ARGF()

`2`	`EARGF(x)`

3 ARGC()

4）bio.h

上面提到，libc.h中包含了print等，这些IO是没有buffer的。而bio.h提供了buffer I/O，这是推荐使用的方式。这个和ANSI标准I/O，stdio.h类似。

根据官方说法，Bio更小、更高效，特别是buffer-at-a-time或line-at-a-time I/O，即使character-at-a-time I/O也比stdio更快。

和其他系统明显不同的是，Plan 9中I/O的接口的文本不是ASCII编码，而是UTF（ISO叫做UTF-8）编码。一个字符在Plan 9中称为rune，也叫做Code-point。（Go中沿用了该叫法）

看一下utf.h中的一个枚举类型

1 {

`2`	`UTFmax = 4,` `/* maximum bytes per rune */`

`3`	`Runesync = 0x80,` `/* cannot represent part of a UTF sequence ( Runeself = 0x80, /* rune and UTF sequences are the same ( Runeerror = 0xFFFD, /* decoding error in UTF */`

`4`	`Runemax = 0x10FFFF,` `/* maximum rune value */`

5 };

引用一段解释：

The library defines several symbols relevant to the representation of characters. Any byte with unsigned value less than Runesync will not appear in any multi-byte encoding of a character. Utfrune compares the character being searched against Runesync to see if it is sufficient to call strchr or if the byte stream must be interpreted. Any byte with unsigned value less than Runeself is represented by a single byte with the same value. Finally, when errors are encountered converting to runes from a byte stream, the library returns the rune value Runeerror and advances a single byte. This permits programs to find runes embedded in binary data.

关于UTF8的操作在utf.h文件中声明了

该文件来源于Inferno操作系统
http://code.google.com/p/inferno-os/source/browse/include/bio.h

5）ar.h

该文件来源于Inferno操作系统
http://code.google.com/p/inferno-os/source/browse/utils/include/ar.h

iar是一个压缩命令，该压缩的文件格式通过ar.h头文件描述。

关于该文件的具体说明，可以查看： http://www.vitanuova.com/inferno/man/10/ar.html

6）bootexec.h/mach.h

bootexec.h 文件来源于Inferno操作系统
http://code.google.com/p/inferno-os/source/browse/utils/libmach/bootexec.h
但注释掉了一些东西

该文件定义了一些架构私有的引导执行程序的文件头格式（引导程序）。这是Plan 9（Inferno的祖先）操作系统的说明：The header format of a bootable executable is defined by each manufacturer. Header file /sys/include/bootexec.h contains structures describing the headers currently supported.

mach.h文件来源于Inferno操作系统：
http://code.google.com/p/inferno-os/source/browse/utils/libmach/a.out.h
http://code.google.com/p/inferno-os/source/browse/utils/libmach/mach.h

该文件定义了一些特定架构的应用程序数据。目前支持的架构：

1 /*

`2`	`* Supported architectures:`

3 * mips,

`4`	`* 68020,`

5 * i386,

`6`	`* amd64,`

`7`	`* sparc,`

`8`	`* sparc64,`

`9`	`* mips2 (R4000)`

10 * arm

`11`	`* powerpc,`

`12`	`* powerpc64`

13 * alpha

14 */

该文件中列出了详细的支持的架构类型（可执行文件）

bootexec.h是针对引导程序的；mach.h是针对应用程序的。

2、src下的lib9/libbio/libmach

由include目录中文件的名字知道，这三个目录分别是libc.h、bio.h和mach.h三个头文件的实现。具体代码有兴趣可以看看。

这些都是Plan 9或Inferno操作系统的库

3、src/cmd 包含了各种工具的源码

目录如下：

5a 5c 5g 5l 6a 6c 6g 6l 8a 8c 8g 8l addr2line api cc cgo dist fix gc go godoc gofmt ld nm objdump pack vet yacc

一个目录对应一个工具
除了go/godoc/gofmt/dist，其他工具的使用方式：
go tool 工具名 xxx

注：这些工具基本来自Plan 9上已有的工具。工具帮助文档：http://plan9.bell-labs.com/sys/man/1/INDEX.html

经过前面的介绍，看到这些名字，应该大概猜到是啥了。

我们看一下Plan 9中文件后缀的问题

前面我们知道，AMD64上，标示是6，我们以这个为例。

根据Plan 9命名规则，AMD64上的C编译器是6c，汇编器是6a，链接器或装载器是6l。c文件编译后生成的对象文件后缀是.6，链接后默认的可执行文件名是6.out。

5/6/8这一序列中，跟Plan 9是一致的，另外，新增了一个g，表示Go编译器。通过这些工具编译Go文件生成的中间文件对象的后缀和C文件编译后是一样的，以.5/6/8结尾。

说到这里提醒一下，目前Go编译不建议直接通过5g/6g/8g这样的进行，而是使用go这个工具（网上很多Go1正式版发布之前的文章用的是6g这样的工具）

5/6/8这一序列中，每个目录下的都有一个doc.go文件，这个文件大概说明了该工具的作用。这一序列工具具体的源码，感兴趣的可以阅读。

1）cc/gc/ld分别是C编译器、Go编译器和链接器

这三个可以看成是对5/6/8序列的抽象（不依赖具体架构）

2）api 可以生产所有Go包的API列表。

GOROOT/api中的go1.txt就可以通过这个工具生产

3）cgo 允许通过调用C代码创建Go包

4）fix 找到用旧API写的Go程序，然后用新API重写他们。

这个可用于Go升级了，处理用之前版本Go写的应用程序。

5）go 管理Go源代码的工具，很好用很重要的一个工具。

应该总是使用go这个工具，而不是使用6g这样的工具。当然，如果需要生产中间对象，可以使用6g这样的工具。

6）godoc 提取并生产Go程序文档（包括Go本身）

7）gofmt 格式化Go程序代码

8）nm 是Plan 9中的nm工具

。详细说明：http://plan9.bell-labs.com/magic/man2html/1/nm 。查看符号表用的

9）pack 是Plan 9中的ar工具，这个用来归档目标文件。

pkg中的.a文件就是pack生成的。详细说明：http://plan9.bell-labs.com/magic/man2html/1/ar

10）vet 用于检查并报告Go源码中可疑的结构。

比如调用Printf，它的参数和格式化字符串提供的不一致，如：fmt.Printf(“%s is %s”, name)，这样会被检查出来。

11）yacc Go版本的yacc。

http://plan9.bell-labs.com/magic/man2html/1/yacc。这是一个经典的生成语法分析器的工具。更多详细说明，可以查阅相关资料。Yacc 与 Lex 快速入门

以上工具目录中都有doc.go文件，用于生成文档。http://golang.org/cmd/可以查看。

12）addr2line linux下有这个命令。

这是一个addr2line的模拟器，只是为了使pprof能够在mac上工作。关于addr2line，可以查看linux的man手册，也可以看addr2line探秘

13）objdump linux下有这个命令。

这是一个objdump的模拟器，只是为了使pprof能够在mac上工作。关于objdump，可以查看linux的man手册

14）dist 这是一个重要的工具。它是一个引导程序，负责构建Go其他基本工具。通过源码安装Go时，会先安装该工具。

注：安装完之后，pkg/tool/$GOOS_$GOARCH下面的pprof工具是从misc下面copy过来的

四、安装脚本

通过源码安装Go相当简单（安装速度也很快），因为它提供了方便的脚本。脚本在src目录下

all.bash/all.bat — 会执行make脚本和run脚本
make.bash/make.bat — 安装Go
run.bash/run.bat — 测试标准库

所以，通过源码安装Go，一般cd到src目录执行./all.bash。如果不想测试标准库，可以直接./make.bash，这样会比较快。

Make.dist 被其他Makefile文件引用，比如cmd下面的很多工具中的Makefile文件。这个文件的作用是：运行go tool dist去安装命令，同时在安装过程中会打印出执行了该文件的目录名。可见，在源码安装Go的过程中，打印出的大部分信息就是这个文件的作用。

五、src/pkg Go标准库源码

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。