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 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