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

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright (C) 2012-2018 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;
  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 /* A static inlined function that is called by another static inlined
 180    function.  */
 181
 182 static inline ATTR int
 183 func_callee (int x)
 184 {
 185   return x * 23;
 186 }
 187
 188 /* A static inlined function that calls another static inlined
 189    function.  The body of the function is as simple as possible so
 190    that both functions are inlined to the same PC address.  */
 191
 192 static int
 193 func_caller (int x)
 194 {
 195   return func_callee (x);
 196 }
 197
 198 /* Entry point.  */
 199
 200 int
 201 main (int argc, char *argv[])
 202 {
 203   /* Declaring x as volatile here prevents GCC from combining calls.
 204      If GCC is allowed to combine calls then some of them end up with
 205      no instructions at all, so there is no specific address for GDB
 206      to set a breakpoint at.  */
 207   volatile int x = argc;
 208
 209   x = func1 (x);
 210
 211   x = func2 (x);
 212
 213   x = func3a (x);
 214
 215   x = func4a (x);
 216
 217   x = func5a (x);
 218
 219   x = func6a (x);
 220
 221   x = func7a (x) + func7b (x);
 222
 223   x = func8a (x) + func8b (x);
 224
 225   x = not_inline_func3 (-21);
 226
 227   func_caller (1);
 228
 229   return x;
 230 }