[dev.typeparams] merge master into dev.typeparams

[gostls13.git] / src / cmd / compile / internal / gc / go.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gc

import (
        "cmd/compile/internal/ssa"
        "cmd/compile/internal/types"
        "cmd/internal/obj"
        "cmd/internal/src"
        "sync"
)

const (
        BADWIDTH = types.BADWIDTH
)

var (
        // maximum size variable which we will allocate on the stack.
        // This limit is for explicit variable declarations like "var x T" or "x := ...".
        // Note: the flag smallframes can update this value.
        maxStackVarSize = int64(10 * 1024 * 1024)

        // maximum size of implicit variables that we will allocate on the stack.
        //   p := new(T)          allocating T on the stack
        //   p := &T{}            allocating T on the stack
        //   s := make([]T, n)    allocating [n]T on the stack
        //   s := []byte("...")   allocating [n]byte on the stack
        // Note: the flag smallframes can update this value.
        maxImplicitStackVarSize = int64(64 * 1024)

        // smallArrayBytes is the maximum size of an array which is considered small.
        // Small arrays will be initialized directly with a sequence of constant stores.
        // Large arrays will be initialized by copying from a static temp.
        // 256 bytes was chosen to minimize generated code + statictmp size.
        smallArrayBytes = int64(256)
)

// isRuntimePkg reports whether p is package runtime.
func isRuntimePkg(p *types.Pkg) bool {
        if compiling_runtime && p == localpkg {
                return true
        }
        return p.Path == "runtime"
}

// isReflectPkg reports whether p is package reflect.
func isReflectPkg(p *types.Pkg) bool {
        if p == localpkg {
                return myimportpath == "reflect"
        }
        return p.Path == "reflect"
}

// The Class of a variable/function describes the "storage class"
// of a variable or function. During parsing, storage classes are
// called declaration contexts.
type Class uint8

//go:generate stringer -type=Class
const (
        Pxxx      Class = iota // no class; used during ssa conversion to indicate pseudo-variables
        PEXTERN                // global variables
        PAUTO                  // local variables
        PAUTOHEAP              // local variables or parameters moved to heap
        PPARAM                 // input arguments
        PPARAMOUT              // output results
        PFUNC                  // global functions

        // Careful: Class is stored in three bits in Node.flags.
        _ = uint((1 << 3) - iota) // static assert for iota <= (1 << 3)
)

// Slices in the runtime are represented by three components:
//
// type slice struct {
//      ptr unsafe.Pointer
//      len int
//      cap int
// }
//
// Strings in the runtime are represented by two components:
//
// type string struct {
//      ptr unsafe.Pointer
//      len int
// }
//
// These variables are the offsets of fields and sizes of these structs.
var (
        slicePtrOffset int64
        sliceLenOffset int64
        sliceCapOffset int64

        sizeofSlice  int64
        sizeofString int64
)

var pragcgobuf [][]string

var outfile string
var linkobj string

// nerrors is the number of compiler errors reported
// since the last call to saveerrors.
var nerrors int

// nsavederrors is the total number of compiler errors
// reported before the last call to saveerrors.
var nsavederrors int

var nsyntaxerrors int

var decldepth int32

var nolocalimports bool

// gc debug flags
type DebugFlags struct {
        P, B, C, E, G,
        K, L, N, S,
        W, e, h, j,
        l, m, r, w int
}

var Debug DebugFlags

var debugstr string

var Debug_checknil int
var Debug_typeassert int

var localpkg *types.Pkg // package being compiled

var inimport bool // set during import

var itabpkg *types.Pkg // fake pkg for itab entries

var itablinkpkg *types.Pkg // fake package for runtime itab entries

var Runtimepkg *types.Pkg // fake package runtime

var racepkg *types.Pkg // package runtime/race

var msanpkg *types.Pkg // package runtime/msan

var unsafepkg *types.Pkg // package unsafe

var trackpkg *types.Pkg // fake package for field tracking

var mappkg *types.Pkg // fake package for map zero value

var gopkg *types.Pkg // pseudo-package for method symbols on anonymous receiver types

var zerosize int64

var myimportpath string

var localimport string

var asmhdr string

var simtype [NTYPE]types.EType

var (
        isInt     [NTYPE]bool
        isFloat   [NTYPE]bool
        isComplex [NTYPE]bool
        issimple  [NTYPE]bool
)

var (
        okforeq    [NTYPE]bool
        okforadd   [NTYPE]bool
        okforand   [NTYPE]bool
        okfornone  [NTYPE]bool
        okforcmp   [NTYPE]bool
        okforbool  [NTYPE]bool
        okforcap   [NTYPE]bool
        okforlen   [NTYPE]bool
        okforarith [NTYPE]bool
        okforconst [NTYPE]bool
)

var (
        okfor [OEND][]bool
        iscmp [OEND]bool
)

var minintval [NTYPE]*Mpint

var maxintval [NTYPE]*Mpint

var minfltval [NTYPE]*Mpflt

var maxfltval [NTYPE]*Mpflt

var xtop []*Node

var exportlist []*Node

var importlist []*Node // imported functions and methods with inlinable bodies

var (
        funcsymsmu sync.Mutex // protects funcsyms and associated package lookups (see func funcsym)
        funcsyms   []*types.Sym
)

var dclcontext Class // PEXTERN/PAUTO

var Curfn *Node

var Widthptr int

var Widthreg int

var nblank *Node

var typecheckok bool

var compiling_runtime bool

// Compiling the standard library
var compiling_std bool

var use_writebarrier bool

var pure_go bool

var flag_installsuffix string

var flag_race bool

var flag_msan bool

var flagDWARF bool

// Whether we are adding any sort of code instrumentation, such as
// when the race detector is enabled.
var instrumenting bool

// Whether we are tracking lexical scopes for DWARF.
var trackScopes bool

// Controls generation of DWARF inlined instance records. Zero
// disables, 1 emits inlined routines but suppresses var info,
// and 2 emits inlined routines with tracking of formals/locals.
var genDwarfInline int

var debuglive int

var Ctxt *obj.Link

var writearchive bool

var nodfp *Node

var disable_checknil int

var autogeneratedPos src.XPos

// interface to back end

type Arch struct {
        LinkArch *obj.LinkArch

        REGSP     int
        MAXWIDTH  int64
        SoftFloat bool

        PadFrame func(int64) int64

        // ZeroRange zeroes a range of memory on stack. It is only inserted
        // at function entry, and it is ok to clobber registers.
        ZeroRange func(*Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog

        Ginsnop      func(*Progs) *obj.Prog
        Ginsnopdefer func(*Progs) *obj.Prog // special ginsnop for deferreturn

        // SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
        SSAMarkMoves func(*SSAGenState, *ssa.Block)

        // SSAGenValue emits Prog(s) for the Value.
        SSAGenValue func(*SSAGenState, *ssa.Value)

        // SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
        // for all values in the block before SSAGenBlock.
        SSAGenBlock func(s *SSAGenState, b, next *ssa.Block)
}

var thearch Arch

var (
        staticuint64s,
        zerobase *Node

        assertE2I,
        assertE2I2,
        assertI2I,
        assertI2I2,
        deferproc,
        deferprocStack,
        Deferreturn,
        Duffcopy,
        Duffzero,
        gcWriteBarrier,
        goschedguarded,
        growslice,
        msanread,
        msanwrite,
        newobject,
        newproc,
        panicdivide,
        panicshift,
        panicdottypeE,
        panicdottypeI,
        panicnildottype,
        panicoverflow,
        raceread,
        racereadrange,
        racewrite,
        racewriterange,
        x86HasPOPCNT,
        x86HasSSE41,
        x86HasFMA,
        armHasVFPv4,
        arm64HasATOMICS,
        typedmemclr,
        typedmemmove,
        Udiv,
        writeBarrier,
        zerobaseSym *obj.LSym

        BoundsCheckFunc [ssa.BoundsKindCount]*obj.LSym
        ExtendCheckFunc [ssa.BoundsKindCount]*obj.LSym

        // Wasm
        WasmMove,
        WasmZero,
        WasmDiv,
        WasmTruncS,
        WasmTruncU,
        SigPanic *obj.LSym
)

// GCWriteBarrierReg maps from registers to gcWriteBarrier implementation LSyms.
var GCWriteBarrierReg map[int16]*obj.LSym