type Builder … type Actor … type ActorFunc … func (f ActorFunc) Act(b *Builder, ctx context.Context, a *Action) error { … } type Action … // BuildActionID returns the action ID section of a's build ID. func (a *Action) BuildActionID() string { … } // BuildContentID returns the content ID section of a's build ID. func (a *Action) BuildContentID() string { … } // BuildID returns a's build ID. func (a *Action) BuildID() string { … } // BuiltTarget returns the actual file that was built. This differs // from Target when the result was cached. func (a *Action) BuiltTarget() string { … } type actionQueue … // Implement heap.Interface func (q *actionQueue) Len() int { … } func (q *actionQueue) Swap(i, j int) { … } func (q *actionQueue) Less(i, j int) bool { … } func (q *actionQueue) Push(x any) { … } func (q *actionQueue) Pop() any { … } func (q *actionQueue) push(a *Action) { … } func (q *actionQueue) pop() *Action { … } type actionJSON … type cacheKey … func actionGraphJSON(a *Action) string { … } type BuildMode … const ModeBuild … const ModeInstall … const ModeBuggyInstall … const ModeVetOnly … // NewBuilder returns a new Builder ready for use. // // If workDir is the empty string, NewBuilder creates a WorkDir if needed // and arranges for it to be removed in case of an unclean exit. // The caller must Close the builder explicitly to clean up the WorkDir // before a clean exit. func NewBuilder(workDir string) *Builder { … } var builderWorkDirs … func (b *Builder) Close() error { … } func closeBuilders() { … } func CheckGOOSARCHPair(goos, goarch string) error { … } // NewObjdir returns the name of a fresh object directory under b.WorkDir. // It is up to the caller to call b.Mkdir on the result at an appropriate time. // The result ends in a slash, so that file names in that directory // can be constructed with direct string addition. // // NewObjdir must be called only from a single goroutine at a time, // so it is safe to call during action graph construction, but it must not // be called during action graph execution. func (b *Builder) NewObjdir() string { … } // readpkglist returns the list of packages that were built into the shared library // at shlibpath. For the native toolchain this list is stored, newline separated, in // an ELF note with name "Go\x00\x00" and type 1. For GCCGO it is extracted from the // .go_export section. func readpkglist(shlibpath string) (pkgs []*load.Package) { … } // cacheAction looks up {mode, p} in the cache and returns the resulting action. // If the cache has no such action, f() is recorded and returned. // TODO(rsc): Change the second key from *load.Package to interface{}, // to make the caching in linkShared less awkward? func (b *Builder) cacheAction(mode string, p *load.Package, f func() *Action) *Action { … } // AutoAction returns the "right" action for go build or go install of p. func (b *Builder) AutoAction(mode, depMode BuildMode, p *load.Package) *Action { … } type buildActor … // newBuildActor returns a new buildActor object, setting up the // covMetaFileName field if 'genCoverMeta' flag is set. func newBuildActor(p *load.Package, genCoverMeta bool) *buildActor { … } func (ba *buildActor) Act(b *Builder, ctx context.Context, a *Action) error { … } // pgoActionID computes the action ID for a preprocess PGO action. func (b *Builder) pgoActionID(input string) cache.ActionID { … } type pgoActor … func (p *pgoActor) Act(b *Builder, ctx context.Context, a *Action) error { … } // CompileAction returns the action for compiling and possibly installing // (according to mode) the given package. The resulting action is only // for building packages (archives), never for linking executables. // depMode is the action (build or install) to use when building dependencies. // To turn package main into an executable, call b.Link instead. func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Action { … } // VetAction returns the action for running go vet on package p. // It depends on the action for compiling p. // If the caller may be causing p to be installed, it is up to the caller // to make sure that the install depends on (runs after) vet. func (b *Builder) VetAction(mode, depMode BuildMode, p *load.Package) *Action { … } func (b *Builder) vetAction(mode, depMode BuildMode, p *load.Package) *Action { … } // LinkAction returns the action for linking p into an executable // and possibly installing the result (according to mode). // depMode is the action (build or install) to use when compiling dependencies. func (b *Builder) LinkAction(mode, depMode BuildMode, p *load.Package) *Action { … } // installAction returns the action for installing the result of a1. func (b *Builder) installAction(a1 *Action, mode BuildMode) *Action { … } // addTransitiveLinkDeps adds to the link action a all packages // that are transitive dependencies of a1.Deps. // That is, if a is a link of package main, a1 is the compile of package main // and a1.Deps is the actions for building packages directly imported by // package main (what the compiler needs). The linker needs all packages // transitively imported by the whole program; addTransitiveLinkDeps // makes sure those are present in a.Deps. // If shlib is non-empty, then a corresponds to the build and installation of shlib, // so any rebuild of shlib should not be added as a dependency. func (b *Builder) addTransitiveLinkDeps(a, a1 *Action, shlib string) { … } // addInstallHeaderAction adds an install header action to a, if needed. // The action a should be an install action as generated by either // b.CompileAction or b.LinkAction with mode=ModeInstall, // and so a.Deps[0] is the corresponding build action. func (b *Builder) addInstallHeaderAction(a *Action) { … } // buildmodeShared takes the "go build" action a1 into the building of a shared library of a1.Deps. // That is, the input a1 represents "go build pkgs" and the result represents "go build -buildmode=shared pkgs". func (b *Builder) buildmodeShared(mode, depMode BuildMode, args []string, pkgs []*load.Package, a1 *Action) *Action { … } // linkSharedAction takes a grouping action a1 corresponding to a list of built packages // and returns an action that links them together into a shared library with the name shlib. // If a1 is nil, shlib should be an absolute path to an existing shared library, // and then linkSharedAction reads that library to find out the package list. func (b *Builder) linkSharedAction(mode, depMode BuildMode, shlib string, a1 *Action) *Action { … }
Codebase Browser
go