funcflags.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  // DO NOT EDIT (use 'go test -v -update-expected' instead.)
     6  // See cmd/compile/internal/inline/inlheur/testdata/props/README.txt
     7  // for more information on the format of this file.
     8  // <endfilepreamble>
     9  
    10  package funcflags
    11  
    12  import "os"
    13  
    14  // funcflags.go T_simple 20 0 1
    15  // Flags FuncPropNeverReturns
    16  // <endpropsdump>
    17  // {"Flags":1,"ParamFlags":null,"ResultFlags":null}
    18  // <endcallsites>
    19  // <endfuncpreamble>
    20  func T_simple() {
    21  	panic("bad")
    22  }
    23  
    24  // funcflags.go T_nested 32 0 1
    25  // Flags FuncPropNeverReturns
    26  // ParamFlags
    27  //   0 ParamFeedsIfOrSwitch
    28  // <endpropsdump>
    29  // {"Flags":1,"ParamFlags":[32],"ResultFlags":null}
    30  // <endcallsites>
    31  // <endfuncpreamble>
    32  func T_nested(x int) {
    33  	if x < 10 {
    34  		panic("bad")
    35  	} else {
    36  		panic("good")
    37  	}
    38  }
    39  
    40  // funcflags.go T_block1 46 0 1
    41  // Flags FuncPropNeverReturns
    42  // <endpropsdump>
    43  // {"Flags":1,"ParamFlags":[0],"ResultFlags":null}
    44  // <endcallsites>
    45  // <endfuncpreamble>
    46  func T_block1(x int) {
    47  	panic("bad")
    48  	if x < 10 {
    49  		return
    50  	}
    51  }
    52  
    53  // funcflags.go T_block2 60 0 1
    54  // ParamFlags
    55  //   0 ParamFeedsIfOrSwitch
    56  // <endpropsdump>
    57  // {"Flags":0,"ParamFlags":[32],"ResultFlags":null}
    58  // <endcallsites>
    59  // <endfuncpreamble>
    60  func T_block2(x int) {
    61  	if x < 10 {
    62  		return
    63  	}
    64  	panic("bad")
    65  }
    66  
    67  // funcflags.go T_switches1 75 0 1
    68  // Flags FuncPropNeverReturns
    69  // ParamFlags
    70  //   0 ParamFeedsIfOrSwitch
    71  // <endpropsdump>
    72  // {"Flags":1,"ParamFlags":[32],"ResultFlags":null}
    73  // <endcallsites>
    74  // <endfuncpreamble>
    75  func T_switches1(x int) {
    76  	switch x {
    77  	case 1:
    78  		panic("one")
    79  	case 2:
    80  		panic("two")
    81  	}
    82  	panic("whatev")
    83  }
    84  
    85  // funcflags.go T_switches1a 92 0 1
    86  // ParamFlags
    87  //   0 ParamFeedsIfOrSwitch
    88  // <endpropsdump>
    89  // {"Flags":0,"ParamFlags":[32],"ResultFlags":null}
    90  // <endcallsites>
    91  // <endfuncpreamble>
    92  func T_switches1a(x int) {
    93  	switch x {
    94  	case 2:
    95  		panic("two")
    96  	}
    97  }
    98  
    99  // funcflags.go T_switches2 106 0 1
   100  // ParamFlags
   101  //   0 ParamFeedsIfOrSwitch
   102  // <endpropsdump>
   103  // {"Flags":0,"ParamFlags":[32],"ResultFlags":null}
   104  // <endcallsites>
   105  // <endfuncpreamble>
   106  func T_switches2(x int) {
   107  	switch x {
   108  	case 1:
   109  		panic("one")
   110  	case 2:
   111  		panic("two")
   112  	default:
   113  		return
   114  	}
   115  	panic("whatev")
   116  }
   117  
   118  // funcflags.go T_switches3 123 0 1
   119  // <endpropsdump>
   120  // {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
   121  // <endcallsites>
   122  // <endfuncpreamble>
   123  func T_switches3(x interface{}) {
   124  	switch x.(type) {
   125  	case bool:
   126  		panic("one")
   127  	case float32:
   128  		panic("two")
   129  	}
   130  }
   131  
   132  // funcflags.go T_switches4 138 0 1
   133  // Flags FuncPropNeverReturns
   134  // <endpropsdump>
   135  // {"Flags":1,"ParamFlags":[0],"ResultFlags":null}
   136  // <endcallsites>
   137  // <endfuncpreamble>
   138  func T_switches4(x int) {
   139  	switch x {
   140  	case 1:
   141  		x++
   142  		fallthrough
   143  	case 2:
   144  		panic("two")
   145  		fallthrough
   146  	default:
   147  		panic("bad")
   148  	}
   149  	panic("whatev")
   150  }
   151  
   152  // funcflags.go T_recov 157 0 1
   153  // <endpropsdump>
   154  // {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
   155  // <endcallsites>
   156  // <endfuncpreamble>
   157  func T_recov(x int) {
   158  	if x := recover(); x != nil {
   159  		panic(x)
   160  	}
   161  }
   162  
   163  // funcflags.go T_forloops1 169 0 1
   164  // Flags FuncPropNeverReturns
   165  // <endpropsdump>
   166  // {"Flags":1,"ParamFlags":[0],"ResultFlags":null}
   167  // <endcallsites>
   168  // <endfuncpreamble>
   169  func T_forloops1(x int) {
   170  	for {
   171  		panic("wokketa")
   172  	}
   173  }
   174  
   175  // funcflags.go T_forloops2 180 0 1
   176  // <endpropsdump>
   177  // {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
   178  // <endcallsites>
   179  // <endfuncpreamble>
   180  func T_forloops2(x int) {
   181  	for {
   182  		println("blah")
   183  		if true {
   184  			break
   185  		}
   186  		panic("warg")
   187  	}
   188  }
   189  
   190  // funcflags.go T_forloops3 195 0 1
   191  // <endpropsdump>
   192  // {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
   193  // <endcallsites>
   194  // <endfuncpreamble>
   195  func T_forloops3(x int) {
   196  	for i := 0; i < 101; i++ {
   197  		println("blah")
   198  		if true {
   199  			continue
   200  		}
   201  		panic("plark")
   202  	}
   203  	for i := range [10]int{} {
   204  		println(i)
   205  		panic("plark")
   206  	}
   207  	panic("whatev")
   208  }
   209  
   210  // funcflags.go T_hasgotos 215 0 1
   211  // <endpropsdump>
   212  // {"Flags":0,"ParamFlags":[0,0],"ResultFlags":null}
   213  // <endcallsites>
   214  // <endfuncpreamble>
   215  func T_hasgotos(x int, y int) {
   216  	{
   217  		xx := x
   218  		panic("bad")
   219  	lab1:
   220  		goto lab2
   221  	lab2:
   222  		if false {
   223  			goto lab1
   224  		} else {
   225  			goto lab4
   226  		}
   227  	lab4:
   228  		if xx < y {
   229  		lab3:
   230  			if false {
   231  				goto lab3
   232  			}
   233  		}
   234  		println(9)
   235  	}
   236  }
   237  
   238  // funcflags.go T_break_with_label 246 0 1
   239  // ParamFlags
   240  //   0 ParamMayFeedIfOrSwitch
   241  //   1 ParamNoInfo
   242  // <endpropsdump>
   243  // {"Flags":0,"ParamFlags":[64,0],"ResultFlags":null}
   244  // <endcallsites>
   245  // <endfuncpreamble>
   246  func T_break_with_label(x int, y int) {
   247  	// presence of break with label should pessimize this func
   248  	// (similar to goto).
   249  	panic("bad")
   250  lab1:
   251  	for {
   252  		println("blah")
   253  		if x < 0 {
   254  			break lab1
   255  		}
   256  		panic("hubba")
   257  	}
   258  }
   259  
   260  // funcflags.go T_callsexit 268 0 1
   261  // Flags FuncPropNeverReturns
   262  // ParamFlags
   263  //   0 ParamFeedsIfOrSwitch
   264  // <endpropsdump>
   265  // {"Flags":1,"ParamFlags":[32],"ResultFlags":null}
   266  // <endcallsites>
   267  // <endfuncpreamble>
   268  func T_callsexit(x int) {
   269  	if x < 0 {
   270  		os.Exit(1)
   271  	}
   272  	os.Exit(2)
   273  }
   274  
   275  // funcflags.go T_exitinexpr 281 0 1
   276  // <endpropsdump>
   277  // {"Flags":0,"ParamFlags":[0],"ResultFlags":null}
   278  // callsite: funcflags.go:286:18|0 flagstr "CallSiteOnPanicPath" flagval 2 score 102 mask 1 maskstr "panicPathAdj"
   279  // <endcallsites>
   280  // <endfuncpreamble>
   281  func T_exitinexpr(x int) {
   282  	// This function does indeed unconditionally call exit, since the
   283  	// first thing it does is invoke exprcallsexit, however from the
   284  	// perspective of this function, the call is not at the statement
   285  	// level, so we'll wind up missing it.
   286  	if exprcallsexit(x) < 0 {
   287  		println("foo")
   288  	}
   289  }
   290  
   291  // funcflags.go T_select_noreturn 297 0 1
   292  // Flags FuncPropNeverReturns
   293  // <endpropsdump>
   294  // {"Flags":1,"ParamFlags":[0,0,0],"ResultFlags":null}
   295  // <endcallsites>
   296  // <endfuncpreamble>
   297  func T_select_noreturn(chi chan int, chf chan float32, p *int) {
   298  	rv := 0
   299  	select {
   300  	case i := <-chi:
   301  		rv = i
   302  	case f := <-chf:
   303  		rv = int(f)
   304  	}
   305  	*p = rv
   306  	panic("bad")
   307  }
   308  
   309  // funcflags.go T_select_mayreturn 314 0 1
   310  // <endpropsdump>
   311  // {"Flags":0,"ParamFlags":[0,0,0],"ResultFlags":[0]}
   312  // <endcallsites>
   313  // <endfuncpreamble>
   314  func T_select_mayreturn(chi chan int, chf chan float32, p *int) int {
   315  	rv := 0
   316  	select {
   317  	case i := <-chi:
   318  		rv = i
   319  		return i
   320  	case f := <-chf:
   321  		rv = int(f)
   322  	}
   323  	*p = rv
   324  	panic("bad")
   325  }
   326  
   327  // funcflags.go T_calls_callsexit 334 0 1
   328  // Flags FuncPropNeverReturns
   329  // <endpropsdump>
   330  // {"Flags":1,"ParamFlags":[0],"ResultFlags":null}
   331  // callsite: funcflags.go:335:15|0 flagstr "CallSiteOnPanicPath" flagval 2 score 102 mask 1 maskstr "panicPathAdj"
   332  // <endcallsites>
   333  // <endfuncpreamble>
   334  func T_calls_callsexit(x int) {
   335  	exprcallsexit(x)
   336  }
   337  
   338  func exprcallsexit(x int) int {
   339  	os.Exit(x)
   340  	return x
   341  }
   342
View as plain text