Home | History | Annotate | Line # | Download | only in gdb.opt 
      1 /* This testcase is part of GDB, the GNU debugger.
      2 
      3    Copyright (C) 2012-2024 Free Software Foundation, Inc.
      4 
      5    This program is free software; you can redistribute it and/or modify
      6    it under the terms of the GNU General Public License as published by
      7    the Free Software Foundation; either version 3 of the License, or
      8    (at your option) any later version.
      9 
     10    This program is distributed in the hope that it will be useful,
     11    but WITHOUT ANY WARRANTY; without even the implied warranty of
     12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13    GNU General Public License for more details.
     14 
     15    You should have received a copy of the GNU General Public License
     16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
     17 
     18 /* The file ../gdb.dwarf2/inline-break.S was generated manually from
     19    this file, and should be regenerated if this file is modified.  */
     20 
     21 #ifdef __GNUC__
     22 # define ATTR __attribute__((gnu_inline)) __attribute__((always_inline))
     23 #else
     24 # define ATTR
     25 #endif
     26 
     27 /* A static inlined function that is called once.  */
     28 
     29 static inline ATTR int
     30 func1 (int x)
     31 {
     32   return x * 23; /* break here */
     33 }
     34 
     35 /* A non-static inlined function that is called once.  */
     36 
     37 inline ATTR int
     38 func2 (int x)
     39 {
     40   return x * 17;
     41 }
     42 
     43 /* A static inlined function that calls another static inlined
     44    function.  */
     45 
     46 static inline ATTR int
     47 func3b (int x)
     48 {
     49   return x < 14 ? 1 : 2;
     50 }
     51 
     52 static inline ATTR int
     53 func3a (int x)
     54 {
     55   return func3b (x * 23);
     56 }
     57 
     58 /* A non-static inlined function that calls a static inlined
     59    function.  */
     60 
     61 static inline ATTR int
     62 func4b (int x)
     63 {
     64   return x < 13 ? 1 : 2;
     65 }
     66 
     67 inline ATTR int
     68 func4a (int x)
     69 {
     70   return func4b (x * 17);
     71 }
     72 
     73 /* A static inlined function that calls a non-static inlined
     74    function.  */
     75 
     76 inline ATTR int
     77 func5b (int x)
     78 {
     79   return x < 12 ? 1 : 2;
     80 }
     81 
     82 static inline ATTR int
     83 func5a (int x)
     84 {
     85   return func5b (x * 23);
     86 }
     87 
     88 /* A non-static inlined function that calls another non-static inlined
     89    function.  */
     90 
     91 inline ATTR int
     92 func6b (int x)
     93 {
     94   return x < 14 ? 3 : 2;
     95 }
     96 
     97 inline ATTR int
     98 func6a (int x)
     99 {
    100   return func6b (x * 17);
    101 }
    102 
    103 /* A static inlined function that is called more than once.  */
    104 
    105 static inline ATTR int
    106 func7b (int x)
    107 {
    108   return x < 23 ? 1 : 4;
    109 }
    110 
    111 static inline ATTR int
    112 func7a (int x)
    113 {
    114   return func7b (x * 29);
    115 }
    116 
    117 /* A non-static inlined function that is called more than once.  */
    118 
    119 inline ATTR int
    120 func8b (int x)
    121 {
    122   return x < 7 ? 11 : 9;
    123 }
    124 
    125 static inline ATTR int
    126 func8a (int x)
    127 {
    128   return func8b (x * 31);
    129 }
    130 
    131 static inline ATTR int
    132 inline_func1 (int x)
    133 {
    134   int y = 1;			/* inline_func1  */
    135 
    136   return y + x;
    137 }
    138 
    139 static int
    140 not_inline_func1 (int x)
    141 {
    142   int y = 2;			/* not_inline_func1  */
    143 
    144   return y + inline_func1 (x);
    145 }
    146 
    147 inline ATTR int
    148 inline_func2 (int x)
    149 {
    150   int y = 3;			/* inline_func2  */
    151 
    152   return y + not_inline_func1 (x);
    153 }
    154 
    155 int
    156 not_inline_func2 (int x)
    157 {
    158   int y = 4;			/* not_inline_func2  */
    159 
    160   return y + inline_func2 (x);
    161 }
    162 
    163 static inline ATTR int
    164 inline_func3 (int x)
    165 {
    166   int y = 5;			/* inline_func3  */
    167 
    168   return y + not_inline_func2 (x);
    169 }
    170 
    171 static int
    172 not_inline_func3 (int x)
    173 {
    174   int y = 6;			/* not_inline_func3  */
    175 
    176   return y + inline_func3 (x);
    177 }
    178 
    179 /* The following three functions serve to exercise GDB's inline frame
    180    skipping logic when setting a user breakpoint on an inline function
    181    by name.  */
    182 
    183 /* A static inlined function that is called by another static inlined
    184    function.  */
    185 
    186 static inline ATTR int
    187 func_inline_callee (int x)
    188 {
    189   return x * 23;
    190 }
    191 
    192 /* A static inlined function that calls another static inlined
    193    function.  The body of the function is as simple as possible so
    194    that both functions are inlined to the same PC address.  */
    195 
    196 static inline ATTR int
    197 func_inline_caller (int x)
    198 {
    199   return func_inline_callee (x);
    200 }
    201 
    202 /* An extern not-inline function that calls a static inlined
    203    function.  */
    204 
    205 int
    206 func_extern_caller (int x)
    207 {
    208   return func_inline_caller (x);
    209 }
    210 
    211 /* Entry point.  */
    212 
    213 int
    214 main (int argc, char *argv[])
    215 {
    216   /* Declaring x as volatile here prevents GCC from combining calls.
    217      If GCC is allowed to combine calls then some of them end up with
    218      no instructions at all, so there is no specific address for GDB
    219      to set a breakpoint at.  */
    220   volatile int x = argc;
    221 
    222   x = func1 (x);
    223 
    224   x = func2 (x);
    225 
    226   x = func3a (x);
    227 
    228   x = func4a (x);
    229 
    230   x = func5a (x);
    231 
    232   x = func6a (x);
    233 
    234   x = func7a (x) + func7b (x);
    235 
    236   x = func8a (x) + func8b (x);
    237 
    238   x = not_inline_func3 (-21);
    239 
    240   func_extern_caller (1);
    241 
    242   return x;
    243 }
    244