compile.go

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package gc
     6  
     7  import (
     8  	"cmp"
     9  	"internal/race"
    10  	"math/rand"
    11  	"slices"
    12  	"sync"
    13  
    14  	"cmd/compile/internal/base"
    15  	"cmd/compile/internal/ir"
    16  	"cmd/compile/internal/liveness"
    17  	"cmd/compile/internal/objw"
    18  	"cmd/compile/internal/pgoir"
    19  	"cmd/compile/internal/ssacompile"
    20  	"cmd/compile/internal/ssagen"
    21  	"cmd/compile/internal/staticinit"
    22  	"cmd/compile/internal/types"
    23  	"cmd/compile/internal/walk"
    24  	"cmd/internal/obj"
    25  )
    26  
    27  // "Portable" code generation.
    28  
    29  var (
    30  	compilequeue []*ir.Func // functions waiting to be compiled
    31  )
    32  
    33  func enqueueFunc(fn *ir.Func, symABIs *ssagen.SymABIs) {
    34  	if ir.FuncName(fn) == "_" {
    35  		// Skip compiling blank functions.
    36  		// Frontend already reported any spec-mandated errors (#29870).
    37  		return
    38  	}
    39  
    40  	if fn.IsClosure() {
    41  		return // we'll get this as part of its enclosing function
    42  	}
    43  
    44  	if ssagen.CreateWasmImportWrapper(fn) {
    45  		return
    46  	}
    47  
    48  	if len(fn.Body) == 0 {
    49  		if needsIntrinsicBody(fn, symABIs) {
    50  			// Generate the function body for a bodyless intrinsic, in case it
    51  			// is used in a non-call context (e.g. as a function pointer).
    52  			// We skip functions defined in assembly, or has a linkname (which
    53  			// could be defined in another package).
    54  			ssagen.GenIntrinsicBody(fn)
    55  		} else {
    56  			// Initialize ABI wrappers if necessary.
    57  			ir.InitLSym(fn, false)
    58  			types.CalcSize(fn.Type())
    59  			a := ssagen.AbiForBodylessFuncStackMap(fn)
    60  			abiInfo := a.ABIAnalyzeFuncType(fn.Type()) // abiInfo has spill/home locations for wrapper
    61  			if fn.ABI == obj.ABI0 {
    62  				// The current args_stackmap generation assumes the function
    63  				// is ABI0, and only ABI0 assembly function can have a FUNCDATA
    64  				// reference to args_stackmap (see cmd/internal/obj/plist.go:Flushplist).
    65  				// So avoid introducing an args_stackmap if the func is not ABI0.
    66  				liveness.WriteFuncMap(fn, abiInfo)
    67  
    68  				x := ssagen.EmitArgInfo(fn, abiInfo)
    69  				objw.Global(x, int32(len(x.P)), obj.RODATA|obj.LOCAL)
    70  			}
    71  			return
    72  		}
    73  	}
    74  
    75  	errorsBefore := base.Errors()
    76  
    77  	todo := []*ir.Func{fn}
    78  	for len(todo) > 0 {
    79  		next := todo[len(todo)-1]
    80  		todo = todo[:len(todo)-1]
    81  
    82  		prepareFunc(next)
    83  		todo = append(todo, next.Closures...)
    84  	}
    85  
    86  	if base.Errors() > errorsBefore {
    87  		return
    88  	}
    89  
    90  	// Enqueue just fn itself. compileFunctions will handle
    91  	// scheduling compilation of its closures after it's done.
    92  	compilequeue = append(compilequeue, fn)
    93  }
    94  
    95  func needsIntrinsicBody(fn *ir.Func, symABIs *ssagen.SymABIs) bool {
    96  	return len(fn.Body) == 0 && ir.IsIntrinsicSym(fn.Sym()) && fn.Sym().Linkname == "" && !symABIs.HasDef(fn.Sym())
    97  }
    98  
    99  // prepareFunc handles any remaining frontend compilation tasks that
   100  // aren't yet safe to perform concurrently.
   101  func prepareFunc(fn *ir.Func) {
   102  	// Set up the function's LSym early to avoid data races with the assemblers.
   103  	// Do this before walk, as walk needs the LSym to set attributes/relocations
   104  	// (e.g. in MarkTypeUsedInInterface).
   105  	ir.InitLSym(fn, true)
   106  
   107  	// If this function is a compiler-generated outlined global map
   108  	// initializer function, register its LSym for later processing.
   109  	if staticinit.MapInitToVar != nil {
   110  		if _, ok := staticinit.MapInitToVar[fn]; ok {
   111  			ssagen.RegisterMapInitLsym(fn.Linksym())
   112  		}
   113  	}
   114  
   115  	// Calculate parameter offsets.
   116  	types.CalcSize(fn.Type())
   117  
   118  	// Generate wrappers between Go ABI and Wasm ABI, for a wasmexport
   119  	// function.
   120  	// Must be done after InitLSym and CalcSize.
   121  	ssagen.GenWasmExportWrapper(fn)
   122  
   123  	walk.Walk(fn)
   124  	if ir.MatchAstDump(fn, "walk") {
   125  		ir.AstDump(fn, "walk, "+ir.FuncName(fn))
   126  	}
   127  
   128  	base.Ctxt.DwTextCount++
   129  }
   130  
   131  // compileFunctions compiles all functions in compilequeue.
   132  // It fans out nBackendWorkers to do the work
   133  // and waits for them to complete.
   134  func compileFunctions(profile *pgoir.Profile) {
   135  	if race.Enabled {
   136  		// Randomize compilation order to try to shake out races.
   137  		tmp := make([]*ir.Func, len(compilequeue))
   138  		perm := rand.Perm(len(compilequeue))
   139  		for i, v := range perm {
   140  			tmp[v] = compilequeue[i]
   141  		}
   142  		copy(compilequeue, tmp)
   143  	} else {
   144  		// Compile the longest functions first,
   145  		// since they're most likely to be the slowest.
   146  		// This helps avoid stragglers.
   147  		// Since we remove from the end of the slice queue,
   148  		// that means shortest to longest.
   149  		slices.SortFunc(compilequeue, func(a, b *ir.Func) int {
   150  			return cmp.Compare(a.NumPreWalkNodes, b.NumPreWalkNodes)
   151  		})
   152  	}
   153  
   154  	var mu sync.Mutex
   155  	var wg sync.WaitGroup
   156  	mu.Lock()
   157  
   158  	for workerId := range base.Flag.LowerC {
   159  		wg.Go(func() {
   160  			var closures []*ir.Func
   161  			for {
   162  				mu.Lock()
   163  				compilequeue = append(compilequeue, closures...)
   164  				remaining := len(compilequeue)
   165  				if remaining == 0 {
   166  					mu.Unlock()
   167  					return
   168  				}
   169  				fn := compilequeue[len(compilequeue)-1]
   170  				compilequeue = compilequeue[:len(compilequeue)-1]
   171  				mu.Unlock()
   172  				ssagen.Compile(ssacompile.Compiler{}, fn, workerId, profile)
   173  				closures = fn.Closures
   174  
   175  				// Free IR data that is no longer needed once machine code has been generated.
   176  				fn.Body = nil
   177  				fn.Dcl = nil
   178  				fn.ClosureVars = nil
   179  				// We need to retain debug info for inlined functions because it is used to build
   180  				// DWARF for the functions that this function was inlined into.
   181  				if !fn.LSym.WasInlined() {
   182  					fn.DebugInfo = nil
   183  				}
   184  			}
   185  		})
   186  	}
   187  
   188  	types.CalcSizeDisabled = true // not safe to calculate sizes concurrently
   189  	base.Ctxt.InParallel = true
   190  
   191  	mu.Unlock()
   192  	wg.Wait()
   193  	compilequeue = nil
   194  
   195  	base.Ctxt.InParallel = false
   196  	types.CalcSizeDisabled = false
   197  
   198  	ssacompile.PostCompile()
   199  }
   200
View as plain text