1 /* Interface between GCC C++ FE and GDB 2 3 Copyright (C) 2014-2021 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_CP_INTERFACE_H 21 #define GCC_CP_INTERFACE_H 22 23 #include "gcc-interface.h" 24 25 /* This header defines the interface to the GCC API. It must be both 26 valid C and valid C++, because it is included by both programs. */ 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif 31 32 /* Forward declaration. */ 33 34 struct gcc_cp_context; 35 36 /* 37 * Definitions and declarations for the C++ front end. 38 */ 39 40 /* Defined versions of the C++ front-end API. */ 41 42 enum gcc_cp_api_version 43 { 44 GCC_CP_FE_VERSION_0 = 0 45 }; 46 47 /* Qualifiers. */ 48 49 enum gcc_cp_qualifiers 50 { 51 GCC_CP_QUALIFIER_CONST = 1, 52 GCC_CP_QUALIFIER_VOLATILE = 2, 53 GCC_CP_QUALIFIER_RESTRICT = 4 54 }; 55 56 /* Ref qualifiers. */ 57 58 enum gcc_cp_ref_qualifiers { 59 GCC_CP_REF_QUAL_NONE = 0, 60 GCC_CP_REF_QUAL_LVALUE = 1, 61 GCC_CP_REF_QUAL_RVALUE = 2 62 }; 63 64 /* Opaque typedef for unbound class templates. They are used for 65 template arguments, and defaults for template template 66 parameters. */ 67 68 typedef unsigned long long gcc_utempl; 69 70 /* Opaque typedef for expressions. They are used for template 71 arguments, defaults for non-type template parameters, and defaults 72 for function arguments. */ 73 74 typedef unsigned long long gcc_expr; 75 76 typedef enum 77 { GCC_CP_TPARG_VALUE, GCC_CP_TPARG_CLASS, 78 GCC_CP_TPARG_TEMPL, GCC_CP_TPARG_PACK } 79 gcc_cp_template_arg_kind; 80 81 typedef union 82 { gcc_expr value; gcc_type type; gcc_utempl templ; gcc_type pack; } 83 gcc_cp_template_arg; 84 85 /* An array of template arguments. */ 86 87 struct gcc_cp_template_args 88 { 89 /* Number of elements. */ 90 91 int n_elements; 92 93 /* kind[i] indicates what kind of template argument type[i] is. */ 94 95 char /* gcc_cp_template_arg_kind */ *kinds; 96 97 /* The template arguments. */ 98 99 gcc_cp_template_arg *elements; 100 }; 101 102 /* An array of (default) function arguments. */ 103 104 struct gcc_cp_function_args 105 { 106 /* Number of elements. */ 107 108 int n_elements; 109 110 /* The (default) values for each argument. */ 111 112 gcc_expr *elements; 113 }; 114 115 /* This enumerates the kinds of decls that GDB can create. */ 116 117 enum gcc_cp_symbol_kind 118 { 119 /* A function. */ 120 121 GCC_CP_SYMBOL_FUNCTION, 122 123 /* A variable. */ 124 125 GCC_CP_SYMBOL_VARIABLE, 126 127 /* A typedef, or an alias declaration (including template ones). */ 128 129 GCC_CP_SYMBOL_TYPEDEF, 130 131 /* A label. */ 132 133 GCC_CP_SYMBOL_LABEL, 134 135 /* A class, forward declared in build_decl (to be later defined in 136 start_class_definition), or, in a template parameter list scope, 137 a declaration of a template class, closing the parameter 138 list. */ 139 140 GCC_CP_SYMBOL_CLASS, 141 142 /* A union, forward declared in build_decl (to be later defined in 143 start_class_definition). */ 144 145 GCC_CP_SYMBOL_UNION, 146 147 /* An enumeration type being introduced with start_new_enum_type. */ 148 149 GCC_CP_SYMBOL_ENUM, 150 151 /* A nonstatic data member being introduced with new_field. */ 152 153 GCC_CP_SYMBOL_FIELD, 154 155 /* A base class in a gcc_vbase_array. */ 156 157 GCC_CP_SYMBOL_BASECLASS, 158 159 /* A using declaration in new_using_decl. */ 160 161 GCC_CP_SYMBOL_USING, 162 163 /* A (lambda) closure class type. In many regards this is just like 164 a regular class, but it's not supposed to have base classes, some 165 of the member functions that are usually implicitly-defined are 166 deleted, and it should have an operator() member function that 167 holds the lambda body. We can't instantiate objects of lambda 168 types from the snippet, but we can interact with them in such 169 ways as passing them to functions that take their types, and 170 calling their body. */ 171 172 GCC_CP_SYMBOL_LAMBDA_CLOSURE, 173 174 /* Marker to check that we haven't exceeded GCC_CP_SYMBOL_MASK. */ 175 GCC_CP_SYMBOL_END, 176 177 GCC_CP_SYMBOL_MASK = 15, 178 179 /* When defining a class member, at least one of the 180 GCC_CP_ACCESS_MASK bits must be set; when defining a namespace- 181 or union-scoped symbol, none of them must be set. */ 182 183 GCC_CP_ACCESS_PRIVATE, 184 GCC_CP_ACCESS_PUBLIC = GCC_CP_ACCESS_PRIVATE << 1, 185 GCC_CP_ACCESS_MASK = (GCC_CP_ACCESS_PUBLIC 186 | GCC_CP_ACCESS_PRIVATE), 187 GCC_CP_ACCESS_PROTECTED = GCC_CP_ACCESS_MASK, 188 GCC_CP_ACCESS_NONE = 0, 189 190 GCC_CP_FLAG_BASE = GCC_CP_ACCESS_PRIVATE << 2, 191 192 /* Flags to be used along with GCC_CP_SYMBOL_FUNCTION: */ 193 194 /* This flag should be set for constructors, destructors and 195 operators. */ 196 GCC_CP_FLAG_SPECIAL_FUNCTION = GCC_CP_FLAG_BASE, 197 198 /* We intentionally cannot express inline, constexpr, or virtual 199 override for functions. We can't inline or constexpr-replace 200 without a source-level body. The override keyword is only 201 meaningful within the definition of the containing class. */ 202 203 /* This indicates a "virtual" member function, explicitly or 204 implicitly (due to a virtual function with the same name and 205 prototype in a base class) declared as such. */ 206 GCC_CP_FLAG_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 1, 207 208 /* The following two flags should only be set when the flag above is 209 set. */ 210 211 /* This indicates a pure virtual member function, i.e., one that is 212 declared with "= 0", even if a body is provided in the 213 definition. */ 214 GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 2, 215 216 /* This indicates a "final" virtual member function. */ 217 GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 3, 218 219 /* This indicates a special member function should have its default 220 implementation. This either means the function declaration 221 contains the "= default" tokens, or that the member function was 222 implicitly generated by the compiler, although the latter use is 223 discouraged: just let the compiler implicitly introduce it. 224 225 A member function defaulted after its first declaration has 226 slightly different ABI implications from one implicitly generated 227 or explicitly defaulted at the declaration (and definition) 228 point. To avoid silent (possibly harmless) violation of the one 229 definition rule, it is recommended that this flag not be used for 230 such functions, and that the address of the definition be 231 supplied instead. */ 232 GCC_CP_FLAG_DEFAULTED_FUNCTION = GCC_CP_FLAG_BASE << 4, 233 234 /* This indicates a deleted member function, i.e., one that has been 235 defined as "= delete" at its declaration point, or one that has 236 been implicitly defined as deleted (with or without an explicit 237 "= default" definition). 238 239 This should not be used for implicitly-declared member functions 240 that resolve to deleted definitions, as it may affect the 241 implicit declaration of other member functions. */ 242 GCC_CP_FLAG_DELETED_FUNCTION = GCC_CP_FLAG_BASE << 5, 243 244 /* This indicates a constructor or type-conversion operator declared 245 as "explicit". */ 246 247 GCC_CP_FLAG_EXPLICIT_FUNCTION = GCC_CP_FLAG_BASE << 6, 248 249 GCC_CP_FLAG_END_FUNCTION, 250 GCC_CP_FLAG_MASK_FUNCTION = (((GCC_CP_FLAG_END_FUNCTION - 1) << 1) 251 - GCC_CP_FLAG_BASE), 252 253 /* Flags to be used along with GCC_CP_SYMBOL_VARIABLE: */ 254 255 /* This indicates a variable declared as "constexpr". */ 256 257 GCC_CP_FLAG_CONSTEXPR_VARIABLE = GCC_CP_FLAG_BASE, 258 259 /* This indicates a variable declared as "thread_local". ??? What 260 should the ADDRESS be? */ 261 262 GCC_CP_FLAG_THREAD_LOCAL_VARIABLE = GCC_CP_FLAG_BASE << 1, 263 264 GCC_CP_FLAG_END_VARIABLE, 265 GCC_CP_FLAG_MASK_VARIABLE = (((GCC_CP_FLAG_END_VARIABLE - 1) << 1) 266 - GCC_CP_FLAG_BASE), 267 268 /* Flags to be used when defining nonstatic data members of classes 269 with new_field. */ 270 271 /* Use this when no flags are present. */ 272 GCC_CP_FLAG_FIELD_NOFLAG = 0, 273 274 /* This indicates the field is declared as mutable. */ 275 GCC_CP_FLAG_FIELD_MUTABLE = GCC_CP_FLAG_BASE, 276 277 GCC_CP_FLAG_END_FIELD, 278 GCC_CP_FLAG_MASK_FIELD = (((GCC_CP_FLAG_END_FIELD - 1) << 1) 279 - GCC_CP_FLAG_BASE), 280 281 /* Flags to be used when defining an enum with 282 start_new_enum_type. */ 283 284 /* This indicates an enum type without any flags. */ 285 GCC_CP_FLAG_ENUM_NOFLAG = 0, 286 287 /* This indicates a scoped enum type. */ 288 GCC_CP_FLAG_ENUM_SCOPED = GCC_CP_FLAG_BASE, 289 290 GCC_CP_FLAG_END_ENUM, 291 GCC_CP_FLAG_MASK_ENUM = (((GCC_CP_FLAG_END_ENUM - 1) << 1) 292 - GCC_CP_FLAG_BASE), 293 294 295 /* Flags to be used when introducing a class or a class template 296 with build_decl. */ 297 298 /* This indicates an enum type without any flags. */ 299 GCC_CP_FLAG_CLASS_NOFLAG = 0, 300 301 /* This indicates the class is actually a struct. This has no 302 effect whatsoever on access control in this interface, since all 303 class members must have explicit access control bits set, but it 304 may affect error messages. */ 305 GCC_CP_FLAG_CLASS_IS_STRUCT = GCC_CP_FLAG_BASE, 306 307 GCC_CP_FLAG_END_CLASS, 308 GCC_CP_FLAG_MASK_CLASS = (((GCC_CP_FLAG_END_CLASS - 1) << 1) 309 - GCC_CP_FLAG_BASE), 310 311 312 /* Flags to be used when introducing a virtual base class in a 313 gcc_vbase_array. */ 314 315 /* This indicates an enum type without any flags. */ 316 GCC_CP_FLAG_BASECLASS_NOFLAG = 0, 317 318 /* This indicates the class is actually a struct. This has no 319 effect whatsoever on access control in this interface, since all 320 class members must have explicit access control bits set, but it 321 may affect error messages. */ 322 GCC_CP_FLAG_BASECLASS_VIRTUAL = GCC_CP_FLAG_BASE, 323 324 GCC_CP_FLAG_END_BASECLASS, 325 GCC_CP_FLAG_MASK_BASECLASS = (((GCC_CP_FLAG_END_BASECLASS - 1) << 1) 326 - GCC_CP_FLAG_BASE), 327 328 329 GCC_CP_FLAG_MASK = (GCC_CP_FLAG_MASK_FUNCTION 330 | GCC_CP_FLAG_MASK_VARIABLE 331 | GCC_CP_FLAG_MASK_FIELD 332 | GCC_CP_FLAG_MASK_ENUM 333 | GCC_CP_FLAG_MASK_CLASS 334 | GCC_CP_FLAG_MASK_BASECLASS 335 ) 336 }; 337 338 339 /* An array of types used for creating lists of base classes. */ 340 341 struct gcc_vbase_array 342 { 343 /* Number of elements. */ 344 345 int n_elements; 346 347 /* The base classes. */ 348 349 gcc_type *elements; 350 351 /* Flags for each base class. Used to indicate access control and 352 virtualness. */ 353 354 enum gcc_cp_symbol_kind *flags; 355 }; 356 357 358 /* This enumerates the types of symbols that GCC might request from 359 GDB. */ 360 361 enum gcc_cp_oracle_request 362 { 363 /* An identifier in namespace scope -- type, variable, function, 364 namespace, template. All namespace-scoped symbols with the 365 requested name, in any namespace (including the global 366 namespace), should be defined in response to this request. */ 367 368 GCC_CP_ORACLE_IDENTIFIER 369 }; 370 371 /* The type of the function called by GCC to ask GDB for a symbol's 372 definition. DATUM is an arbitrary value supplied when the oracle 373 function is registered. CONTEXT is the GCC context in which the 374 request is being made. REQUEST specifies what sort of symbol is 375 being requested, and IDENTIFIER is the name of the symbol. */ 376 377 typedef void gcc_cp_oracle_function (void *datum, 378 struct gcc_cp_context *context, 379 enum gcc_cp_oracle_request request, 380 const char *identifier); 381 382 /* The type of the function called by GCC to ask GDB for a symbol's 383 address. This should return 0 if the address is not known. */ 384 385 typedef gcc_address gcc_cp_symbol_address_function (void *datum, 386 struct gcc_cp_context *ctxt, 387 const char *identifier); 388 389 /* The type of the function called by GCC to ask GDB to enter or leave 390 the user expression scope. */ 391 392 typedef void gcc_cp_enter_leave_user_expr_scope_function (void *datum, 393 struct gcc_cp_context 394 *context); 395 396 /* The vtable used by the C front end. */ 397 398 struct gcc_cp_fe_vtable 399 { 400 /* The version of the C interface. The value is one of the 401 gcc_cp_api_version constants. */ 402 403 unsigned int cp_version; 404 405 /* Set the callbacks for this context. 406 407 The binding oracle is called whenever the C++ parser needs to 408 look up a symbol. This gives the caller a chance to lazily 409 instantiate symbols using other parts of the gcc_cp_fe_interface 410 API. The symbol is looked up without a scope, and the oracle 411 must supply a definition for ALL namespace-scoped definitions 412 bound to the symbol. 413 414 The address oracle is called whenever the C++ parser needs to 415 look up a symbol. This may be called for symbols not provided by 416 the symbol oracle, such as built-in functions where GCC provides 417 the declaration; other internal symbols, such as those related 418 with thunks, rtti, and virtual tables are likely to be queried 419 through this interface too. The identifier is a mangled symbol 420 name. 421 422 DATUM is an arbitrary piece of data that is passed back verbatim 423 to the callbacks in requests. */ 424 425 void (*set_callbacks) (struct gcc_cp_context *self, 426 gcc_cp_oracle_function *binding_oracle, 427 gcc_cp_symbol_address_function *address_oracle, 428 gcc_cp_enter_leave_user_expr_scope_function *enter_scope, 429 gcc_cp_enter_leave_user_expr_scope_function *leave_scope, 430 void *datum); 431 432 #define GCC_METHOD0(R, N) \ 433 R (*N) (struct gcc_cp_context *); 434 #define GCC_METHOD1(R, N, A) \ 435 R (*N) (struct gcc_cp_context *, A); 436 #define GCC_METHOD2(R, N, A, B) \ 437 R (*N) (struct gcc_cp_context *, A, B); 438 #define GCC_METHOD3(R, N, A, B, C) \ 439 R (*N) (struct gcc_cp_context *, A, B, C); 440 #define GCC_METHOD4(R, N, A, B, C, D) \ 441 R (*N) (struct gcc_cp_context *, A, B, C, D); 442 #define GCC_METHOD5(R, N, A, B, C, D, E) \ 443 R (*N) (struct gcc_cp_context *, A, B, C, D, E); 444 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ 445 R (*N) (struct gcc_cp_context *, A, B, C, D, E, F, G); 446 447 #include "gcc-cp-fe.def" 448 449 #undef GCC_METHOD0 450 #undef GCC_METHOD1 451 #undef GCC_METHOD2 452 #undef GCC_METHOD3 453 #undef GCC_METHOD4 454 #undef GCC_METHOD5 455 #undef GCC_METHOD7 456 457 }; 458 459 /* The C front end object. */ 460 461 struct gcc_cp_context 462 { 463 /* Base class. */ 464 465 struct gcc_base_context base; 466 467 /* Our vtable. This is a separate field because this is simpler 468 than implementing a vtable inheritance scheme in C. */ 469 470 const struct gcc_cp_fe_vtable *cp_ops; 471 }; 472 473 /* The name of the .so that the compiler builds. We dlopen this 474 later. */ 475 476 #define GCC_CP_FE_LIBCC libcc1.so 477 478 /* The compiler exports a single initialization function. This macro 479 holds its name as a symbol. */ 480 481 #define GCC_CP_FE_CONTEXT gcc_cp_fe_context 482 483 /* The type of the initialization function. The caller passes in the 484 desired base version and desired C-specific version. If the 485 request can be satisfied, a compatible gcc_context object will be 486 returned. Otherwise, the function returns NULL. */ 487 488 typedef struct gcc_cp_context *gcc_cp_fe_context_function 489 (enum gcc_base_api_version, 490 enum gcc_cp_api_version); 491 492 #ifdef __cplusplus 493 } 494 #endif 495 496 #endif /* GCC_CP_INTERFACE_H */ 497