function_properties.go

     1  // Copyright 2023 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 inlheur
     6  
     7  // This file defines a set of Go function "properties" intended to
     8  // guide inlining heuristics; these properties may apply to the
     9  // function as a whole, or to one or more function return values or
    10  // parameters.
    11  //
    12  // IMPORTANT: function properties are produced on a "best effort"
    13  // basis, meaning that the code that computes them doesn't verify that
    14  // the properties are guaranteed to be true in 100% of cases. For this
    15  // reason, properties should only be used to drive always-safe
    16  // optimization decisions (e.g. "should I inline this call", or
    17  // "should I unroll this loop") as opposed to potentially unsafe IR
    18  // alterations that could change program semantics (e.g. "can I delete
    19  // this variable" or "can I move this statement to a new location").
    20  //
    21  //----------------------------------------------------------------
    22  
    23  // FuncProps describes a set of function or method properties that may
    24  // be useful for inlining heuristics. Here 'Flags' are properties that
    25  // we think apply to the entire function; 'RecvrParamFlags' are
    26  // properties of specific function params (or the receiver), and
    27  // 'ResultFlags' are things properties we think will apply to values
    28  // of specific results. Note that 'ParamFlags' includes and entry for
    29  // the receiver if applicable, and does include etries for blank
    30  // params; for a function such as "func foo(_ int, b byte, _ float32)"
    31  // the length of ParamFlags will be 3.
    32  type FuncProps struct {
    33  	Flags       FuncPropBits
    34  	ParamFlags  []ParamPropBits // slot 0 receiver if applicable
    35  	ResultFlags []ResultPropBits
    36  }
    37  
    38  type FuncPropBits uint32
    39  
    40  const (
    41  	// Function always panics or invokes os.Exit() or a func that does
    42  	// likewise.
    43  	FuncPropNeverReturns FuncPropBits = 1 << iota
    44  )
    45  
    46  type ParamPropBits uint32
    47  
    48  const (
    49  	// No info about this param
    50  	ParamNoInfo ParamPropBits = 0
    51  
    52  	// Parameter value feeds unmodified into a top-level interface
    53  	// call (this assumes the parameter is of interface type).
    54  	ParamFeedsInterfaceMethodCall ParamPropBits = 1 << iota
    55  
    56  	// Parameter value feeds unmodified into an interface call that
    57  	// may be conditional/nested and not always executed (this assumes
    58  	// the parameter is of interface type).
    59  	ParamMayFeedInterfaceMethodCall ParamPropBits = 1 << iota
    60  
    61  	// Parameter value feeds unmodified into a top level indirect
    62  	// function call (assumes parameter is of function type).
    63  	ParamFeedsIndirectCall
    64  
    65  	// Parameter value feeds unmodified into an indirect function call
    66  	// that is conditional/nested (not guaranteed to execute). Assumes
    67  	// parameter is of function type.
    68  	ParamMayFeedIndirectCall
    69  
    70  	// Parameter value feeds unmodified into a top level "switch"
    71  	// statement or "if" statement simple expressions (see more on
    72  	// "simple" expression classification below).
    73  	ParamFeedsIfOrSwitch
    74  
    75  	// Parameter value feeds unmodified into a "switch" or "if"
    76  	// statement simple expressions (see more on "simple" expression
    77  	// classification below), where the if/switch is
    78  	// conditional/nested.
    79  	ParamMayFeedIfOrSwitch
    80  )
    81  
    82  type ResultPropBits uint32
    83  
    84  const (
    85  	// No info about this result
    86  	ResultNoInfo ResultPropBits = 0
    87  	// This result always contains allocated memory.
    88  	ResultIsAllocatedMem ResultPropBits = 1 << iota
    89  	// This result is always a single concrete type that is
    90  	// implicitly converted to interface.
    91  	ResultIsConcreteTypeConvertedToInterface
    92  	// Result is always the same non-composite compile time constant.
    93  	ResultAlwaysSameConstant
    94  	// Result is always the same function or closure.
    95  	ResultAlwaysSameFunc
    96  	// Result is always the same (potentially) inlinable function or closure.
    97  	ResultAlwaysSameInlinableFunc
    98  )
    99
View as plain text