gdb/testsuite/gdb.opt/inline-break.c

   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 }