1/* This testcase is part of GDB, the GNU debugger. 2 3 Copyright (C) 2012-2020 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 29static inline ATTR int 30func1 (int x) 31{ 32 return x * 23; /* break here */ 33} 34 35/* A non-static inlined function that is called once. */ 36 37inline ATTR int 38func2 (int x) 39{ 40 return x * 17; 41} 42 43/* A static inlined function that calls another static inlined 44 function. */ 45 46static inline ATTR int 47func3b (int x) 48{ 49 return x < 14 ? 1 : 2; 50} 51 52static inline ATTR int 53func3a (int x) 54{ 55 return func3b (x * 23); 56} 57 58/* A non-static inlined function that calls a static inlined 59 function. */ 60 61static inline ATTR int 62func4b (int x) 63{ 64 return x < 13 ? 1 : 2; 65} 66 67inline ATTR int 68func4a (int x) 69{ 70 return func4b (x * 17); 71} 72 73/* A static inlined function that calls a non-static inlined 74 function. */ 75 76inline ATTR int 77func5b (int x) 78{ 79 return x < 12 ? 1 : 2; 80} 81 82static inline ATTR int 83func5a (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 91inline ATTR int 92func6b (int x) 93{ 94 return x < 14 ? 3 : 2; 95} 96 97inline ATTR int 98func6a (int x) 99{ 100 return func6b (x * 17); 101} 102 103/* A static inlined function that is called more than once. */ 104 105static inline ATTR int 106func7b (int x) 107{ 108 return x < 23 ? 1 : 4; 109} 110 111static inline ATTR int 112func7a (int x) 113{ 114 return func7b (x * 29); 115} 116 117/* A non-static inlined function that is called more than once. */ 118 119inline ATTR int 120func8b (int x) 121{ 122 return x < 7 ? 11 : 9; 123} 124 125static inline ATTR int 126func8a (int x) 127{ 128 return func8b (x * 31); 129} 130 131static inline ATTR int 132inline_func1 (int x) 133{ 134 int y = 1; /* inline_func1 */ 135 136 return y + x; 137} 138 139static int 140not_inline_func1 (int x) 141{ 142 int y = 2; /* not_inline_func1 */ 143 144 return y + inline_func1 (x); 145} 146 147inline ATTR int 148inline_func2 (int x) 149{ 150 int y = 3; /* inline_func2 */ 151 152 return y + not_inline_func1 (x); 153} 154 155int 156not_inline_func2 (int x) 157{ 158 int y = 4; /* not_inline_func2 */ 159 160 return y + inline_func2 (x); 161} 162 163static inline ATTR int 164inline_func3 (int x) 165{ 166 int y = 5; /* inline_func3 */ 167 168 return y + not_inline_func2 (x); 169} 170 171static int 172not_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 186static inline ATTR int 187func_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 196static inline ATTR int 197func_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 205int 206func_extern_caller (int x) 207{ 208 return func_inline_caller (x); 209} 210 211/* Entry point. */ 212 213int 214main (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