1 /* Interface between GCC C++ FE and GDB -*- c -*- 2 3 Copyright (C) 2014-2024 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 21 22 /* Push namespace NAME as the current binding level, to which 23 newly-introduced decls will be bound. An empty string identifies 24 the global namespace, whereas NULL identifies an anonymous 25 namespace. A namespace named NAME is created in the current scope, 26 if needed. 27 28 If the newly-created namespace is to be an inline namespace, see 29 make_namespace_inline. */ 30 31 GCC_METHOD1 (int /* bool */, push_namespace, 32 const char *) /* Argument NAME. */ 33 34 /* Push TYPE as the current binding level, making its members visible 35 for name lookup. The current scope before the call must be the 36 scope in which the class was declared. This should be used if the 37 definition of a class is already finished, but one wishes to define 38 a nested class, or to enter the scope of one of its member 39 functions. */ 40 41 GCC_METHOD1 (int /* bool */, push_class, 42 gcc_type) /* Argument TYPE. */ 43 44 /* Push FUNCTION_DECL as the current (empty) binding level (see 45 reactivate_decl). The current enclosing scope before the call must 46 be the scope in which the function was declared. */ 47 48 GCC_METHOD1 (int /* bool */, push_function, 49 gcc_decl) /* Argument FUNCTION_DECL. */ 50 51 /* Make DECL visible (again?) within SCOPE. When SCOPE is NULL, it 52 means the current scope; if it is not NULL, it must name a function 53 that is currently active, even if not at the top of the binding 54 chain. 55 56 This function can be used to make e.g. a global function or 57 variable visible in a namespace or local scope (overriding another 58 enclosing definition of the same name), but its most common 59 expected use of this primitive, that gives it its name, is to make 60 declarations visible again after reentering a function scope, 61 because when a function is entered with push_function, that does 62 NOT make any of the declarations nested in it visible for name 63 lookup. 64 65 There is a reason/excuse for that: unlike namespaces and classes, 66 G++ doesn't ever have to reenter function scopes, so its name 67 resolution infrastructure is not prepared to do that. But wait, 68 there is also a good use for this apparent limitation: a function 69 may contain multiple scopes (blocks), and the name may be bound to 70 different symbols in each of these scopes. With this interface, as 71 we reenter a function scope, we may choose which symbols to make 72 visible for the code snippet, or, if there could be template 73 functions in local scopes, for unresolved names in nested template 74 class default arguments, or in nested template function signatures. 75 76 As for making a local declaration visible for the code snippet, 77 there are two possibilities: a) introduce it upfront, while 78 entering the scope for the user expression (see the enter_scope 79 callback, called by g++ when encountering the push_user_expression 80 pragma), which might save some scope switching and reactivate_decl 81 (though this can't be helped if some declarations have to be 82 introduced and discarded, because of multiple definitions of the 83 same name in different scopes within a function: they have to be 84 defined in discriminator order); or b) introduce it when its name 85 is looked up, entering the scope, introducing the declaration, 86 leaving the scope, and then reactivating the declaration in its 87 local scope. 88 89 Here's some more detail on how reactivate_decl works. Say there's 90 a function foo whose body looks like this: 91 92 { 93 { 94 // point 1 95 class c {} o __attribute__ ((__used__)); // c , o 96 } 97 struct c { 98 void f() { 99 // point 2 100 } 101 } o __attribute__ ((__used__)); // c_0, o_0 102 { 103 class c {} p __attribute__ ((__used__)); // c_1, p 104 // point 3 105 o.f(); 106 } 107 } 108 109 When we are about to define class c at point 1, we enter the 110 function foo scope, and since no symbols are visible at point 1, we 111 proceed to declare class c. We may then define the class right 112 away, or, if we leave the function scope, and we later wish to 113 define it, or to define object o, we can reenter the scope and just 114 use the previously-obtained gcc_decl to define the class, without 115 having to reactivate the declaration. 116 117 Now, if we are to set up the binding context for point 2, we have 118 to define c_0::f, and in order to do so, we have to declare and 119 define c_0. Before we can declare c_0, we MUST at least declare c. 120 121 As a general rule, before we can declare or define any local name 122 with a discriminator, we have to at least declare any other 123 occurrences of the same name in the same enclosing entity with 124 lower or absent discriminator. 125 126 So, we declare c, then we leave the function scope and reenter it 127 so as to declare c_0 (also with name "c", which is why we have to 128 leave and reenter the function scope, otherwise we would get an 129 error because of the duplicate definition; g++ will assign a 130 discriminator because it still remembers there was an earlier 131 declaration of c_0 within the function, it's just no longer in 132 scope), then we can define c_0, including its member function f. 133 134 Likewise, if we wish to define o_0, we have to define o first. If 135 we wish to declare (and maybe then define) c_1, we have to at least 136 declare (c and then) c_0 first. 137 138 Then, as we set up the binding context to compile a code snippet at 139 point 3, we may choose to activate c_1, o_0 and p upfront, 140 declaring and discarding c, c_0 and o, and then reentering the 141 funciton scope to declare c_1, o_0 and p; or we can wait for oracle 142 lookups of c, o or p. If c is looked up, and the debugger resolves 143 c in the scope to c_1, it is expected to enter the function scope 144 from the top level, declare c, leave it, reenter it, declare c_0, 145 leave it, reenter it, declare c_1, leave it, and then reactivate 146 c_1 in the function scope. If c_1 is needed as a complete type, 147 the definition may be given right after the declaration, or the 148 scope will have to be reentered in order to define the class. 149 150 . If the code snippet is at point 2, we don't need to (re)activate 151 any declaration: nothing from any local scope is visible. Just 152 entering the scope of the class containing member function f 153 reactivates the names of its members, including the class name 154 itself. */ 155 156 GCC_METHOD2 (int /* bool */, reactivate_decl, 157 gcc_decl, /* Argument DECL. */ 158 gcc_decl) /* Argument SCOPE. */ 159 160 /* Pop the namespace last entered with push_namespace, or class last 161 entered with push_class, or function last entered with 162 push_function, restoring the binding level in effect before the 163 matching push_* call. */ 164 165 GCC_METHOD0 (int /* bool */, pop_binding_level) 166 167 /* Return the NAMESPACE_DECL, TYPE_DECL or FUNCTION_DECL of the 168 binding level that would be popped by pop_scope. */ 169 170 GCC_METHOD0 (gcc_decl, get_current_binding_level_decl) 171 172 /* Make the current binding level an inline namespace. It must be a 173 namespace to begin with. It is safe to call this more than once 174 for the same namespace, but after the first call, subsequent ones 175 will not return a success status. */ 176 177 GCC_METHOD0 (int /* bool */, make_namespace_inline) 178 179 /* Add USED_NS to the namespaces used by the current binding level. 180 Use get_current_binding_level_decl to obtain USED_NS's 181 gcc_decl. */ 182 183 GCC_METHOD1 (int /* bool */, add_using_namespace, 184 gcc_decl) /* Argument USED_NS. */ 185 186 /* Introduce a namespace alias declaration, as in: 187 188 namespace foo = [... ::] bar; 189 190 After this call, namespace TARGET will be visible as ALIAS within 191 the current namespace. Get the declaration for TARGET by calling 192 get_current_binding_level_decl after pushing into it. */ 193 194 GCC_METHOD2 (int /* bool */, add_namespace_alias, 195 const char *, /* Argument ALIAS. */ 196 gcc_decl) /* Argument TARGET. */ 197 198 /* Introduce a using declaration, as in: 199 200 using foo::bar; 201 202 The TARGET decl names the qualifying scope (foo:: above) and the 203 identifier (bar), but that does not mean that only TARGET will be 204 brought into the current scope: all bindings of TARGET's identifier 205 in the qualifying scope will be brought in. 206 207 FLAGS should specify GCC_CP_SYMBOL_USING. If the current scope is 208 a class scope, visibility flags must be supplied. 209 210 Even when TARGET is template dependent, we don't need to specify 211 whether or not it is a typename: the supplied declaration (that 212 could be a template-dependent type converted to declaration by 213 get_type_decl) indicates so. */ 214 215 GCC_METHOD2 (int /* bool */, add_using_decl, 216 enum gcc_cp_symbol_kind, /* Argument FLAGS. */ 217 gcc_decl) /* Argument TARGET. */ 218 219 /* Create a new "decl" in GCC, and bind it in the current binding 220 level. A decl is a declaration, basically a kind of symbol. 221 222 NAME is the name of the new symbol. SYM_KIND is the kind of 223 symbol being requested. SYM_TYPE is the new symbol's C++ type; 224 except for labels, where this is not meaningful and should be 225 zero. If SUBSTITUTION_NAME is not NULL, then a reference to this 226 decl in the source will later be substituted with a dereference 227 of a variable of the given name. Otherwise, for symbols having 228 an address (e.g., functions), ADDRESS is the address. FILENAME 229 and LINE_NUMBER refer to the symbol's source location. If this 230 is not known, FILENAME can be NULL and LINE_NUMBER can be 0. 231 This function returns the new decl. 232 233 Use this function to register typedefs, functions and variables to 234 namespace and local binding levels, and typedefs, member functions 235 (static or not), and static data members to class binding levels. 236 Class members must have their access controls specified with 237 GCC_CP_ACCESS_* flags in SYM_KIND. 238 239 Note that, since access controls are disabled, we have no means to 240 express private, protected and public. 241 242 There are various flags that can be set in SYM_KIND to specify 243 additional semantics. Look for GCC_CP_FLAGs in the definition of 244 enum gcc_cp_symbol_kind in gcc-cp-interface.h. 245 246 In order to define member functions, pass GCC_CP_SYMBOL_FUNCTION in 247 SYM_KIND, and a function_type for static member functions or a 248 method type for non-static member functions, including constructors 249 and destructors. Use build_function_type to create a function 250 type; for a method type, start by creating a function type without 251 any compiler-introduced artificial arguments (the implicit this 252 pointer, and the __in_chrg added to constructors and destructors, 253 and __vtt_parm added to the former), and then use build_method_type 254 to create the method type out of the class type and the function 255 type. 256 257 For operator functions, set GCC_CP_FLAG_SPECIAL_FUNCTION in 258 SYM_KIND, in addition to any other applicable flags, and pass as 259 NAME a string starting with the two-character mangling for operator 260 name: "ps" for unary plus, "mL" for multiply and assign, *=; etc. 261 Use "cv" for type converstion operators (the target type portion 262 may be omitted, as it is taken from the return type in SYM_TYPE). 263 For operator"", use "li" followed by the identifier (the mangled 264 name mandates digits specifying the length of the identifier; if 265 present, they determine the end of the identifier, otherwise, the 266 identifier extents to the end of the string, so that "li3_Kme" and 267 "li_Km" are equivalent). 268 269 Constructors and destructors need special care, because for each 270 constructor and destructor there may be multiple clones defined 271 internally by the compiler. With build_decl, you can introduce the 272 base declaration of a constructor or a destructor, setting 273 GCC_CP_FLAG_SPECIAL_FUNCTION the flag and using names starting with 274 capital "C" or "D", respectively, followed by a digit (see below), 275 a blank, or NUL ('\0'). DO NOT supply an ADDRESS or a 276 SUBSTITUTION_NAME to build_decl, it would be meaningless (and 277 rejected) for the base declaration; use define_cdtor_clone to 278 introduce the address of each clone. For constructor templates, 279 declare the template with build_decl, and then, for each 280 specialization, introduce it with 281 build_function_template_specialization, and then define the 282 addresses of each of its clones with define_cdtor_clone. 283 284 NAMEs for GCC_CP_FLAG_SPECIAL_FUNCTION: 285 286 NAME meaning 287 C? constructor base declaration (? may be 1, 2, 4, blank or NUL) 288 D? destructor base declaration (? may be 0, 1, 2, 4, blank or NUL) 289 nw operator new 290 na operator new[] 291 dl operator delete 292 da operator delete[] 293 ps operator + (unary) 294 ng operator - (unary) 295 ad operator & (unary) 296 de operator * (unary) 297 co operator ~ 298 pl operator + 299 mi operator - 300 ml operator * 301 dv operator / 302 rm operator % 303 an operator & 304 or operator | 305 eo operator ^ 306 aS operator = 307 pL operator += 308 mI operator -= 309 mL operator *= 310 dV operator /= 311 rM operator %= 312 aN operator &= 313 oR operator |= 314 eO operator ^= 315 ls operator << 316 rs operator >> 317 lS operator <<= 318 rS operator >>= 319 eq operator == 320 ne operator != 321 lt operator < 322 gt operator > 323 le operator <= 324 ge operator >= 325 nt operator ! 326 aa operator && 327 oo operator || 328 pp operator ++ 329 mm operator -- 330 cm operator , 331 pm operator ->* 332 pt operator -> 333 cl operator () 334 ix operator [] 335 qu operator ? 336 cv operator <T> (conversion operator) 337 li<id> operator "" <id> 338 339 FIXME: How about attributes? */ 340 341 GCC_METHOD7 (gcc_decl, build_decl, 342 const char *, /* Argument NAME. */ 343 enum gcc_cp_symbol_kind, /* Argument SYM_KIND. */ 344 gcc_type, /* Argument SYM_TYPE. */ 345 const char *, /* Argument SUBSTITUTION_NAME. */ 346 gcc_address, /* Argument ADDRESS. */ 347 const char *, /* Argument FILENAME. */ 348 unsigned int) /* Argument LINE_NUMBER. */ 349 350 /* Supply the ADDRESS of one of the multiple clones of constructor or 351 destructor CDTOR. The clone is specified by NAME, using the 352 following name mangling conventions: 353 354 C1 in-charge constructor 355 C2 not-in-charge constructor 356 C4 unified constructor 357 D0 deleting destructor 358 D1 in-charge destructor 359 D2 not-in-charge destructor 360 D4 unified destructor 361 362 The following information is not necessary to use the API. 363 364 C1 initializes an instance of the class (rather than of derived 365 classes), including virtual base classes, whereas C2 initializes a 366 sub-object (of the given class type) of an instance of some derived 367 class (or a full object that doesn't have any virtual base 368 classes). 369 370 D0 and D1 destruct an instance of the class, including virtual base 371 classes, but only the former calls operator delete to release the 372 object's storage at the end; D2 destructs a sub-object (of the 373 given class type) of an instance of a derived class (or a full 374 object that doesn't have any virtual base classes). 375 376 The [CD]4 manglings (and symbol definitions) are non-standard, but 377 GCC uses them in some cases: rather than assuming they are 378 in-charge or not-in-charge, they test the implicit argument that 379 the others ignore to tell how to behave. These are used instead of 380 cloning when we just can't use aliases. */ 381 382 GCC_METHOD3 (gcc_decl, define_cdtor_clone, 383 const char *, /* Argument NAME. */ 384 gcc_decl, /* Argument CDTOR. */ 385 gcc_address) /* Argument ADDRESS. */ 386 387 /* Return the type associated with the given declaration. This is 388 most useful to obtain the type associated with a forward-declared 389 class, because it is the gcc_type, rather than the gcc_decl, that 390 has to be used to build other types, but build_decl returns a 391 gcc_decl rather than a gcc_type. This call can in theory be used 392 to obtain the type from any other declaration; it is supposed to 393 return the same type that was supplied when the declaration was 394 created. */ 395 396 GCC_METHOD1 (gcc_type, get_decl_type, 397 gcc_decl) /* Argument DECL. */ 398 399 /* Return the declaration for a type. */ 400 401 GCC_METHOD1 (gcc_decl, get_type_decl, 402 gcc_type) /* Argument TYPE. */ 403 404 /* Declare DECL as a friend of the current class scope, if TYPE is 405 NULL, or of TYPE itself otherwise. DECL may be a function or a 406 class, be they template generics, template specializations or not 407 templates. TYPE must be a class type (not a template generic). 408 409 The add_friend call cannot introduce a declaration; even if the 410 friend is first declared as a friend in the source code, the 411 declaration belongs in the enclosing namespace, so it must be 412 introduced in that namespace, and the resulting declaration can 413 then be made a friend. 414 415 DECL cannot, however, be a member of a template class generic, 416 because we have no means to introduce their declarations. This 417 interface has no notion of definitions for template generics. As a 418 consequence, users of this interface must introduce each friend 419 template member specialization separately, i.e., instead of: 420 421 template <typename T> friend struct X<T>::M; 422 423 they must be declared as if they were: 424 425 friend struct X<onetype>::M; 426 friend struct X<anothertype>::M; 427 ... for each specialization of X. 428 429 430 Specializations of a template can have each others' members as 431 friends: 432 433 template <typename T> class foo { 434 int f(); 435 template <typename U> friend int foo<U>::f(); 436 }; 437 438 It wouldn't always be possible to define all specializations of a 439 template class before introducing the friend declarations in their 440 expanded, per-specialization form. 441 442 In order to simplify such friend declarations, and to enable 443 incremental friend declarations as template specializations are 444 introduced, add_friend can be called after the befriending class is 445 fully defined, passing it a non-NULL TYPE argument naming the 446 befriending class type. */ 447 448 GCC_METHOD2 (int /* bool */, add_friend, 449 gcc_decl, /* Argument DECL. */ 450 gcc_type) /* Argument TYPE. */ 451 452 /* Return the type of a pointer to a given base type. */ 453 454 GCC_METHOD1 (gcc_type, build_pointer_type, 455 gcc_type) /* Argument BASE_TYPE. */ 456 457 /* Return the type of a reference to a given base type. */ 458 459 GCC_METHOD2 (gcc_type, build_reference_type, 460 gcc_type, /* Argument BASE_TYPE. */ 461 enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ 462 463 /* Create a new pointer-to-member type. MEMBER_TYPE is the data 464 member type, while CLASS_TYPE is the class type containing the data 465 member. For pointers to member functions, MEMBER_TYPE must be a 466 method type, and CLASS_TYPE must be specified even though it might 467 be possible to extract it from the method type. */ 468 469 GCC_METHOD2 (gcc_type, build_pointer_to_member_type, 470 gcc_type, /* Argument CLASS_TYPE. */ 471 gcc_type) /* Argument MEMBER_TYPE. */ 472 473 /* Start a template parameter list scope and enters it, so that 474 subsequent build_type_template_parameter and 475 build_value_template_parameter calls create template parameters in 476 the list. The list is closed by a build_decl call with 477 GCC_CP_SYMBOL_FUNCTION or GCC_CP_SYMBOL_CLASS, that, when the scope 478 is a template parameter list, declares a template function or a 479 template class with the then-closed parameter list. The scope in 480 which the new declaration is to be introduced by build_decl must be 481 entered before calling start_template_decl, and build_decl returns 482 to that scope, from the template parameter list scope, before 483 introducing the declaration. */ 484 485 GCC_METHOD0 (int /* bool */, start_template_decl) 486 487 /* Build a typename template-parameter (e.g., the T in template 488 <typename T = X>). Either PACK_P should be nonzero, to indicate an 489 argument pack (the last argument in a variadic template argument 490 list, as in template <typename... T>), or DEFAULT_TYPE may be 491 non-NULL to set the default type argument (e.g. X) for the template 492 parameter. FILENAME and LINE_NUMBER may specify the source 493 location in which the template parameter was declared. */ 494 495 GCC_METHOD5 (gcc_type, build_type_template_parameter, 496 const char *, /* Argument ID. */ 497 int /* bool */, /* Argument PACK_P. */ 498 gcc_type, /* Argument DEFAULT_TYPE. */ 499 const char *, /* Argument FILENAME. */ 500 unsigned int) /* Argument LINE_NUMBER. */ 501 502 /* Build a template template-parameter (e.g., the T in template 503 <template <[...]> class T = X>). DEFAULT_TEMPL may be non-NULL to 504 set the default type-template argument (e.g. X) for the template 505 template parameter. FILENAME and LINE_NUMBER may specify the 506 source location in which the template parameter was declared. */ 507 508 GCC_METHOD5 (gcc_utempl, build_template_template_parameter, 509 const char *, /* Argument ID. */ 510 int /* bool */, /* Argument PACK_P. */ 511 gcc_utempl, /* Argument DEFAULT_TEMPL. */ 512 const char *, /* Argument FILENAME. */ 513 unsigned int) /* Argument LINE_NUMBER. */ 514 515 /* Build a value template-parameter (e.g., the V in template <typename 516 T, T V> or in template <int V = X>). DEFAULT_VALUE may be non-NULL 517 to set the default value argument for the template parameter (e.g., 518 X). FILENAME and LINE_NUMBER may specify the source location in 519 which the template parameter was declared. */ 520 521 GCC_METHOD5 (gcc_decl, build_value_template_parameter, 522 gcc_type, /* Argument TYPE. */ 523 const char *, /* Argument ID. */ 524 gcc_expr, /* Argument DEFAULT_VALUE. */ 525 const char *, /* Argument FILENAME. */ 526 unsigned int) /* Argument LINE_NUMBER. */ 527 528 /* Build a template-dependent typename (e.g., typename T::bar or 529 typename T::template bart<X>). ENCLOSING_TYPE should be the 530 template-dependent nested name specifier (e.g., T), ID should be 531 the name of the member of the ENCLOSING_TYPE (e.g., bar or bart), 532 and TARGS should be non-NULL and specify the template arguments 533 (e.g. <X>) iff ID is to name a class template. 534 535 In this and other calls, a template-dependent nested name specifier 536 may be a template class parameter (build_type_template_parameter), 537 a specialization (returned by build_dependent_type_template_id) of 538 a template template parameter (returned by 539 build_template_template_parameter) or a member type thereof 540 (returned by build_dependent_typename itself). */ 541 542 GCC_METHOD3 (gcc_type, build_dependent_typename, 543 gcc_type, /* Argument ENCLOSING_TYPE. */ 544 const char *, /* Argument ID. */ 545 const struct gcc_cp_template_args *) /* Argument TARGS. */ 546 547 /* Build a template-dependent class template (e.g., T::template bart). 548 ENCLOSING_TYPE should be the template-dependent nested name 549 specifier (e.g., T), ID should be the name of the class template 550 member of the ENCLOSING_TYPE (e.g., bart). */ 551 552 GCC_METHOD2 (gcc_utempl, build_dependent_class_template, 553 gcc_type, /* Argument ENCLOSING_TYPE. */ 554 const char *) /* Argument ID. */ 555 556 /* Build a template-dependent type template-id (e.g., T<A>). 557 TEMPLATE_DECL should be a template template parameter (e.g., the T 558 in template <template <[...]> class T = X>), and TARGS should 559 specify the template arguments (e.g. <A>). */ 560 561 GCC_METHOD2 (gcc_type, build_dependent_type_template_id, 562 gcc_utempl, /* Argument TEMPLATE_DECL. */ 563 const struct gcc_cp_template_args *) /* Argument TARGS. */ 564 565 /* Build a template-dependent expression (e.g., S::val or S::template 566 mtf<X>, or unqualified f or template tf<X>). 567 568 ENCLOSING_SCOPE should be a template-dependent nested name 569 specifier (e.g., T), a resolved namespace or class decl, or NULL 570 for unqualified names; ID should be the name of the member of the 571 ENCLOSING_SCOPE (e.g., val or mtf) or unqualified overloaded 572 function; and TARGS should list template arguments (e.g. <X>) when 573 mtf or tf are to name a template function, or be NULL otherwise. 574 575 Unqualified names and namespace- or class-qualified names can only 576 resolve to overloaded functions, to be used in contexts that 577 involve overload resolution that cannot be resolved because of 578 template-dependent argument or return types, such as call 579 expressions with template-dependent arguments, conversion 580 expressions to function types with template-dependent argument 581 types or the like. Other cases of unqualified or 582 non-template-dependent-qualified names should NOT use this 583 function, and use decl_expr to convert the appropriate function or 584 object declaration to an expression. 585 586 If ID is the name of a special member function, FLAGS should be 587 GCC_CP_SYMBOL_FUNCTION|GCC_CP_FLAG_SPECIAL_FUNCTION, and ID should 588 be one of the encodings for special member functions documented in 589 build_decl. Otherwise, FLAGS should be GCC_CP_SYMBOL_MASK, which 590 suggests the symbol kind is not known (though we know it is not a 591 type). 592 593 If ID denotes a conversion operator, CONV_TYPE should name the 594 target type of the conversion. Otherwise, CONV_TYPE must be 595 NULL. */ 596 597 GCC_METHOD5 (gcc_expr, build_dependent_expr, 598 gcc_decl, /* Argument ENCLOSING_SCOPE. */ 599 enum gcc_cp_symbol_kind, /* Argument FLAGS. */ 600 const char *, /* Argument NAME. */ 601 gcc_type, /* Argument CONV_TYPE. */ 602 const struct gcc_cp_template_args *) /* Argument TARGS. */ 603 604 /* Build a gcc_expr for the value VALUE in type TYPE. */ 605 606 GCC_METHOD2 (gcc_expr, build_literal_expr, 607 gcc_type, /* Argument TYPE. */ 608 unsigned long) /* Argument VALUE. */ 609 610 /* Build a gcc_expr that denotes DECL, the declaration of a variable 611 or function in namespace scope, or of a static member variable or 612 function. Use QUALIFIED_P to build the operand of unary & so as to 613 compute a pointer-to-member, rather than a regular pointer. */ 614 615 GCC_METHOD2 (gcc_expr, build_decl_expr, 616 gcc_decl, /* Argument DECL. */ 617 int /* bool */) /* Argument QUALIFIED_P. */ 618 619 /* Build a gcc_expr that denotes the unary operation UNARY_OP applied 620 to the gcc_expr OPERAND. For non-expr operands, see 621 unary_type_expr. Besides the UNARY_OP encodings used for operator 622 names, we support "pp_" for preincrement, and "mm_" for 623 predecrement, "nx" for noexcept, "tw" for throw, "tr" for rethrow 624 (pass NULL as the operand), "te" for typeid, "sz" for sizeof, "az" 625 for alignof, "dl" for delete, "gsdl" for ::delete, "da" for 626 delete[], "gsda" for ::delete[], "sp" for pack expansion, "sZ" for 627 sizeof...(function argument pack). */ 628 629 GCC_METHOD2 (gcc_expr, build_unary_expr, 630 const char *, /* Argument UNARY_OP. */ 631 gcc_expr) /* Argument OPERAND. */ 632 633 /* Build a gcc_expr that denotes the binary operation BINARY_OP 634 applied to gcc_exprs OPERAND1 and OPERAND2. Besides the BINARY_OP 635 encodings used for operator names, we support "ds" for the operator 636 token ".*" and "dt" for the operator token ".". When using 637 operators that take a name as their second operand ("." and "->") 638 use decl_expr to convert the gcc_decl of the member name to a 639 gcc_expr, if the member name wasn't created with 640 e.g. build_dependent_expr. */ 641 642 GCC_METHOD3 (gcc_expr, build_binary_expr, 643 const char *, /* Argument BINARY_OP. */ 644 gcc_expr, /* Argument OPERAND1. */ 645 gcc_expr) /* Argument OPERAND2. */ 646 647 /* Build a gcc_expr that denotes the ternary operation TERNARY_OP 648 applied to gcc_exprs OPERAND1, OPERAND2 and OPERAND3. The only 649 supported TERNARY_OP is "qu", for the "?:" operator. */ 650 651 GCC_METHOD4 (gcc_expr, build_ternary_expr, 652 const char *, /* Argument TERNARY_OP. */ 653 gcc_expr, /* Argument OPERAND1. */ 654 gcc_expr, /* Argument OPERAND2. */ 655 gcc_expr) /* Argument OPERAND3. */ 656 657 /* Build a gcc_expr that denotes the unary operation UNARY_OP applied 658 to the gcc_type OPERAND. Supported unary operations taking types 659 are "ti" for typeid, "st" for sizeof, "at" for alignof, and "sZ" 660 for sizeof...(template argument pack). */ 661 662 GCC_METHOD2 (gcc_expr, build_unary_type_expr, 663 const char *, /* Argument UNARY_OP. */ 664 gcc_type) /* Argument OPERAND. */ 665 666 /* Build a gcc_expr that denotes the binary operation BINARY_OP 667 applied to gcc_type OPERAND1 and gcc_expr OPERAND2. Use this for 668 all kinds of (single-argument) type casts ("dc", "sc", "cc", "rc" 669 for dynamic, static, const and reinterpret casts, respectively; 670 "cv" for functional or C-style casts). */ 671 672 GCC_METHOD3 (gcc_expr, build_cast_expr, 673 const char *, /* Argument BINARY_OP. */ 674 gcc_type, /* Argument OPERAND1. */ 675 gcc_expr) /* Argument OPERAND2. */ 676 677 /* Build a gcc_expr that denotes the conversion of an expression list 678 VALUES to TYPE, with ("tl") or without ("cv") braces, or a braced 679 initializer list of unspecified type (e.g., a component of another 680 braced initializer list; pass "il" for CONV_OP, and NULL for 681 TYPE). */ 682 683 GCC_METHOD3 (gcc_expr, build_expression_list_expr, 684 const char *, /* Argument CONV_OP. */ 685 gcc_type, /* Argument TYPE. */ 686 const struct gcc_cp_function_args *) /* Argument VALUES. */ 687 688 /* Build a gcc_expr that denotes a new ("nw") or new[] ("na") 689 expression of TYPE, with or without a GLOBAL_NS qualifier (prefix 690 the NEW_OP with "gs"), with or without PLACEMENT, with or without 691 INITIALIZER. If it's not a placement new, PLACEMENT must be NULL 692 (rather than a zero-length placement arg list). If there's no 693 specified initializer, INITIALIZER must be NULL; a zero-length arg 694 list stands for a default initializer. */ 695 696 GCC_METHOD4 (gcc_expr, build_new_expr, 697 const char *, /* Argument NEW_OP. */ 698 const struct gcc_cp_function_args *, /* Argument PLACEMENT. */ 699 gcc_type, /* Argument TYPE. */ 700 const struct gcc_cp_function_args *) /* Argument INITIALIZER. */ 701 702 /* Return a call expression that calls CALLABLE with arguments ARGS. 703 CALLABLE may be a function, a callable object, a pointer to 704 function, an unresolved expression, an unresolved overload set, an 705 object expression combined with a member function overload set or a 706 pointer-to-member. If QUALIFIED_P, CALLABLE will be interpreted as 707 a qualified name, preventing virtual function dispatch. */ 708 709 GCC_METHOD3 (gcc_expr, build_call_expr, 710 gcc_expr, /* Argument CALLABLE. */ 711 int /* bool */, /* Argument QUALIFIED_P. */ 712 const struct gcc_cp_function_args *) /* Argument ARGS. */ 713 714 /* Return the type of the gcc_expr OPERAND. 715 Use this for decltype. 716 For decltype (auto), pass a NULL OPERAND. 717 718 Note: for template-dependent expressions, the result is NULL, 719 because the type is only computed when template argument 720 substitution is performed. */ 721 722 GCC_METHOD1 (gcc_type, get_expr_type, 723 gcc_expr) /* Argument OPERAND. */ 724 725 /* Introduce a specialization of a template function. 726 727 TEMPLATE_DECL is the template function, and TARGS are the arguments 728 for the specialization. ADDRESS is the address of the 729 specialization. FILENAME and LINE_NUMBER specify the source 730 location associated with the template function specialization. */ 731 732 GCC_METHOD5 (gcc_decl, build_function_template_specialization, 733 gcc_decl, /* Argument TEMPLATE_DECL. */ 734 const struct gcc_cp_template_args *, /* Argument TARGS. */ 735 gcc_address, /* Argument ADDRESS. */ 736 const char *, /* Argument FILENAME. */ 737 unsigned int) /* Argument LINE_NUMBER. */ 738 739 /* Specialize a template class as an incomplete type. A definition 740 can be supplied later, with start_class_type. 741 742 TEMPLATE_DECL is the template class, and TARGS are the arguments 743 for the specialization. FILENAME and LINE_NUMBER specify the 744 source location associated with the template class 745 specialization. */ 746 747 GCC_METHOD4 (gcc_decl, build_class_template_specialization, 748 gcc_decl, /* Argument TEMPLATE_DECL. */ 749 const struct gcc_cp_template_args *, /* Argument TARGS. */ 750 const char *, /* Argument FILENAME. */ 751 unsigned int) /* Argument LINE_NUMBER. */ 752 753 /* Start defining a 'class', 'struct' or 'union' type, entering its 754 own binding level. Initially it has no fields. 755 756 TYPEDECL is the forward-declaration of the type, returned by 757 build_decl. BASE_CLASSES indicate the base classes of class NAME. 758 FILENAME and LINE_NUMBER specify the source location associated 759 with the class definition, should they be different from those of 760 the forward declaration. */ 761 762 GCC_METHOD4 (gcc_type, start_class_type, 763 gcc_decl, /* Argument TYPEDECL. */ 764 const struct gcc_vbase_array *,/* Argument BASE_CLASSES. */ 765 const char *, /* Argument FILENAME. */ 766 unsigned int) /* Argument LINE_NUMBER. */ 767 768 /* Create a new closure class type, record it as the 769 DISCRIMINATOR-numbered closure type in the current scope (or 770 associated with EXTRA_SCOPE, if non-NULL), and enter the closure 771 type's own binding level. This primitive would sort of combine 772 build_decl and start_class_type, if they could be used to introduce 773 a closure type. Initially it has no fields. 774 775 FILENAME and LINE_NUMBER specify the source location associated 776 with the class. EXTRA_SCOPE, if non-NULL, must be a PARM_DECL of 777 the current function, or a FIELD_DECL of the current class. If it 778 is NULL, the current scope must be a function. */ 779 780 GCC_METHOD5 (gcc_type, start_closure_class_type, 781 int, /* Argument DISCRIMINATOR. */ 782 gcc_decl, /* Argument EXTRA_SCOPE. */ 783 enum gcc_cp_symbol_kind, /* Argument FLAGS. */ 784 const char *, /* Argument FILENAME. */ 785 unsigned int) /* Argument LINE_NUMBER. */ 786 787 /* Add a non-static data member to the most-recently-started 788 unfinished struct or union type. FIELD_NAME is the field's name. 789 FIELD_TYPE is the type of the field. BITSIZE and BITPOS indicate 790 where in the struct the field occurs. */ 791 792 GCC_METHOD5 (gcc_decl, build_field, 793 const char *, /* Argument FIELD_NAME. */ 794 gcc_type, /* Argument FIELD_TYPE. */ 795 enum gcc_cp_symbol_kind, /* Argument FIELD_FLAGS. */ 796 unsigned long, /* Argument BITSIZE. */ 797 unsigned long) /* Argument BITPOS. */ 798 799 /* After all the fields have been added to a struct, class or union, 800 the struct or union type must be "finished". This does some final 801 cleanups in GCC, and pops to the binding level that was in effect 802 before the matching start_class_type or 803 start_closure_class_type. */ 804 805 GCC_METHOD1 (int /* bool */, finish_class_type, 806 unsigned long) /* Argument SIZE_IN_BYTES. */ 807 808 /* Create a new 'enum' type, and record it in the current binding 809 level. The new type initially has no associated constants. 810 811 NAME is the enum name. FILENAME and LINE_NUMBER specify its source 812 location. */ 813 814 GCC_METHOD5 (gcc_type, start_enum_type, 815 const char *, /* Argument NAME. */ 816 gcc_type, /* Argument UNDERLYING_INT_TYPE. */ 817 enum gcc_cp_symbol_kind, /* Argument FLAGS. */ 818 const char *, /* Argument FILENAME. */ 819 unsigned int) /* Argument LINE_NUMBER. */ 820 821 /* Add a new constant to an enum type. NAME is the constant's name 822 and VALUE is its value. Returns a gcc_decl for the constant. */ 823 824 GCC_METHOD3 (gcc_decl, build_enum_constant, 825 gcc_type, /* Argument ENUM_TYPE. */ 826 const char *, /* Argument NAME. */ 827 unsigned long) /* Argument VALUE. */ 828 829 /* After all the constants have been added to an enum, the type must 830 be "finished". This does some final cleanups in GCC. */ 831 832 GCC_METHOD1 (int /* bool */, finish_enum_type, 833 gcc_type) /* Argument ENUM_TYPE. */ 834 835 /* Create a new function type. RETURN_TYPE is the type returned by 836 the function, and ARGUMENT_TYPES is a vector, of length NARGS, of 837 the argument types. IS_VARARGS is true if the function is 838 varargs. */ 839 840 GCC_METHOD3 (gcc_type, build_function_type, 841 gcc_type, /* Argument RETURN_TYPE. */ 842 const struct gcc_type_array *,/* Argument ARGUMENT_TYPES. */ 843 int /* bool */) /* Argument IS_VARARGS. */ 844 845 /* Create a variant of a function type with an exception 846 specification. FUNCTION_TYPE is a function or method type. 847 EXCEPT_TYPES is an array with the list of exception types. Zero as 848 the array length implies throw() AKA noexcept(true); NULL as the 849 pointer to gcc_type_array implies noexcept(false), which is almost 850 equivalent (but distinguishable by the compiler) to an unspecified 851 exception list. */ 852 853 GCC_METHOD2 (gcc_type, build_exception_spec_variant, 854 gcc_type, /* Argument FUNCTION_TYPE. */ 855 const struct gcc_type_array *)/* Argument EXCEPT_TYPES. */ 856 857 /* Create a new non-static member function type. FUNC_TYPE is the 858 method prototype, without the implicit THIS pointer, added as a 859 pointer to the QUALS-qualified CLASS_TYPE. If CLASS_TYPE is NULL, 860 this creates a cv-qualified (member) function type not associated 861 with any specific class, as needed to support "typedef void f(int) 862 const;", which can later be used to declare member functions and 863 pointers to member functions. */ 864 865 GCC_METHOD4 (gcc_type, build_method_type, 866 gcc_type, /* Argument CLASS_TYPE. */ 867 gcc_type, /* Argument FUNC_TYPE. */ 868 enum gcc_cp_qualifiers, /* Argument QUALS. */ 869 enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ 870 871 /* Return a declaration for the (INDEX - 1)th argument of 872 FUNCTION_DECL, i.e., for the first argument, use zero as the index. 873 If FUNCTION_DECL is a non-static member function, use -1 to get the 874 implicit THIS parameter. */ 875 876 GCC_METHOD2 (gcc_decl, get_function_parameter_decl, 877 gcc_decl, /* Argument FUNCTION_DECL. */ 878 int) /* Argument INDEX. */ 879 880 /* Return a lambda expr that constructs an instance of CLOSURE_TYPE. 881 Only lambda exprs without any captures can be correctly created 882 through these mechanisms; that's all we need to support lambdas 883 expressions in default parameters, the only kind that may have to 884 be introduced through this interface. */ 885 886 GCC_METHOD1 (gcc_expr, build_lambda_expr, 887 gcc_type) /* Argument CLOSURE_TYPE. */ 888 889 /* Return an integer type with the given properties. If BUILTIN_NAME 890 is non-NULL, it must name a builtin integral type with the given 891 signedness and size, and that is the type that will be returned. */ 892 893 GCC_METHOD3 (gcc_type, get_int_type, 894 int /* bool */, /* Argument IS_UNSIGNED. */ 895 unsigned long, /* Argument SIZE_IN_BYTES. */ 896 const char *) /* Argument BUILTIN_NAME. */ 897 898 /* Return the 'char' type, a distinct type from both 'signed char' and 899 'unsigned char' returned by int_type. */ 900 901 GCC_METHOD0 (gcc_type, get_char_type) 902 903 /* Return a floating point type with the given properties. If BUILTIN_NAME 904 is non-NULL, it must name a builtin integral type with the given 905 signedness and size, and that is the type that will be returned. */ 906 907 GCC_METHOD2 (gcc_type, get_float_type, 908 unsigned long, /* Argument SIZE_IN_BYTES. */ 909 const char *) /* Argument BUILTIN_NAME. */ 910 911 /* Return the 'void' type. */ 912 913 GCC_METHOD0 (gcc_type, get_void_type) 914 915 /* Return the 'bool' type. */ 916 917 GCC_METHOD0 (gcc_type, get_bool_type) 918 919 /* Return the std::nullptr_t type. */ 920 921 GCC_METHOD0 (gcc_type, get_nullptr_type) 922 923 /* Return the nullptr constant. */ 924 925 GCC_METHOD0 (gcc_expr, get_nullptr_constant) 926 927 /* Create a new array type. If NUM_ELEMENTS is -1, then the array 928 is assumed to have an unknown length. */ 929 930 GCC_METHOD2 (gcc_type, build_array_type, 931 gcc_type, /* Argument ELEMENT_TYPE. */ 932 int) /* Argument NUM_ELEMENTS. */ 933 934 /* Create a new array type. NUM_ELEMENTS is a template-dependent 935 expression. */ 936 937 GCC_METHOD2 (gcc_type, build_dependent_array_type, 938 gcc_type, /* Argument ELEMENT_TYPE. */ 939 gcc_expr) /* Argument NUM_ELEMENTS. */ 940 941 /* Create a new variably-sized array type. UPPER_BOUND_NAME is the 942 name of a local variable that holds the upper bound of the array; 943 it is one less than the array size. */ 944 945 GCC_METHOD2 (gcc_type, build_vla_array_type, 946 gcc_type, /* Argument ELEMENT_TYPE. */ 947 const char *) /* Argument UPPER_BOUND_NAME. */ 948 949 /* Return a qualified variant of a given base type. QUALIFIERS says 950 which qualifiers to use; it is composed of or'd together 951 constants from 'enum gcc_cp_qualifiers'. */ 952 953 GCC_METHOD2 (gcc_type, build_qualified_type, 954 gcc_type, /* Argument UNQUALIFIED_TYPE. */ 955 enum gcc_cp_qualifiers) /* Argument QUALIFIERS. */ 956 957 /* Build a complex type given its element type. */ 958 959 GCC_METHOD1 (gcc_type, build_complex_type, 960 gcc_type) /* Argument ELEMENT_TYPE. */ 961 962 /* Build a vector type given its element type and number of 963 elements. */ 964 965 GCC_METHOD2 (gcc_type, build_vector_type, 966 gcc_type, /* Argument ELEMENT_TYPE. */ 967 int) /* Argument NUM_ELEMENTS. */ 968 969 /* Build a constant. NAME is the constant's name and VALUE is its 970 value. FILENAME and LINE_NUMBER refer to the type's source 971 location. If this is not known, FILENAME can be NULL and 972 LINE_NUMBER can be 0. */ 973 974 GCC_METHOD5 (int /* bool */, build_constant, 975 gcc_type, /* Argument TYPE. */ 976 const char *, /* Argument NAME. */ 977 unsigned long, /* Argument VALUE. */ 978 const char *, /* Argument FILENAME. */ 979 unsigned int) /* Argument LINE_NUMBER. */ 980 981 /* Emit an error and return an error type object. */ 982 983 GCC_METHOD1 (gcc_type, error, 984 const char *) /* Argument MESSAGE. */ 985 986 /* Declare a static_assert with the given CONDITION and ERRORMSG at 987 FILENAME:LINE_NUMBER. */ 988 989 GCC_METHOD4 (int /* bool */, add_static_assert, 990 gcc_expr, /* Argument CONDITION. */ 991 const char *, /* Argument ERRORMSG. */ 992 const char *, /* Argument FILENAME. */ 993 unsigned int) /* Argument LINE_NUMBER. */ 994 995 #if 0 996 997 /* FIXME: We don't want to expose the internal implementation detail 998 that default parms are stored in function types, and it's not clear 999 how this or other approaches would interact with the type sharing 1000 of e.g. ctor clones, so we're leaving this out, since default args 1001 are not even present in debug information anyway. Besides, the set 1002 of default args for a function may grow within its scope, and vary 1003 independently in other scopes. */ 1004 1005 /* Create a modified version of a function type that has default 1006 values for some of its arguments. The returned type should ONLY be 1007 used to define functions or methods, never to declare parameters, 1008 variables, types or the like. 1009 1010 DEFAULTS must have at most as many N_ELEMENTS as there are 1011 arguments without default values in FUNCTION_TYPE. Say, if 1012 FUNCTION_TYPE has an argument list such as (T1, T2, T3, T4 = V0) 1013 and DEFAULTS has 2 elements (V1, V2), the returned type will have 1014 the following argument list: (T1, T2 = V1, T3 = V2, T4 = V0). 1015 1016 Any NULL expressions in DEFAULTS will be marked as deferred, and 1017 they should be filled in with set_deferred_function_default_args. */ 1018 1019 GCC_METHOD2 (gcc_type, add_function_default_args, 1020 gcc_type, /* Argument FUNCTION_TYPE. */ 1021 const struct gcc_cp_function_args *) /* Argument DEFAULTS. */ 1022 1023 /* Fill in the first deferred default args in FUNCTION_DECL with the 1024 expressions given in DEFAULTS. This can be used when the 1025 declaration of a parameter is needed to create a default 1026 expression, such as taking the size of an earlier parameter, or 1027 building a lambda expression in the parameter's context. */ 1028 1029 GCC_METHOD2 (int /* bool */, set_deferred_function_default_args, 1030 gcc_decl, /* Argument FUNCTION_DECL. */ 1031 const struct gcc_cp_function_args *) /* Argument DEFAULTS. */ 1032 1033 #endif 1034 1035 1036 /* When you add entry points, add them at the end, so that the new API 1037 version remains compatible with the old version. 1038 1039 The following conventions have been observed as to naming entry points: 1040 1041 - build_* creates (and maybe records) something and returns it; 1042 - add_* creates and records something, but doesn't return it; 1043 - get_* obtains something without creating it; 1044 - start_* marks the beginning of a compound (type, list, ...); 1045 - finish_* completes the compound when needed. 1046 1047 Entry points that return an int (bool) and don't have a return value 1048 specification return nonzero (true) on success and zero (false) on 1049 failure. This is in line with libcc1's conventions of returning a 1050 zero-initialized value in case of e.g. a transport error. */ 1051
Indexes created Sun Mar 01 05:31:48 UTC 2026