diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/ChangeLog | 184 | ||||
| -rw-r--r-- | include/ansidecl.h | 64 | ||||
| -rw-r--r-- | include/aout/adobe.h | 167 | ||||
| -rw-r--r-- | include/aout/aout64.h | 6 | ||||
| -rw-r--r-- | include/aout/hp300hpux.h | 54 | ||||
| -rw-r--r-- | include/bfdlink.h | 3 | ||||
| -rw-r--r-- | include/dis-asm.h | 2 | ||||
| -rw-r--r-- | include/dwarf2.def | 1 | ||||
| -rw-r--r-- | include/dwarf2.h | 2 | ||||
| -rw-r--r-- | include/elf/arc-reloc.def | 7 | ||||
| -rw-r--r-- | include/elf/common.h | 27 | ||||
| -rw-r--r-- | include/elf/hppa.h | 2 | ||||
| -rw-r--r-- | include/elf/ppc.h | 1 | ||||
| -rw-r--r-- | include/gcc-c-fe.def | 35 | ||||
| -rw-r--r-- | include/gcc-c-interface.h | 21 | ||||
| -rw-r--r-- | include/gcc-cp-fe.def | 1050 | ||||
| -rw-r--r-- | include/gcc-cp-interface.h | 496 | ||||
| -rw-r--r-- | include/gcc-interface.h | 109 | ||||
| -rw-r--r-- | include/gdb/remote-sim.h | 2 | ||||
| -rw-r--r-- | include/libiberty.h | 2 | ||||
| -rw-r--r-- | include/longlong.h | 65 | ||||
| -rw-r--r-- | include/mach-o/arm.h | 2 | ||||
| -rw-r--r-- | include/opcode/arc-func.h | 15 | ||||
| -rw-r--r-- | include/opcode/arc.h | 1 | ||||
| -rw-r--r-- | include/opcode/nds32.h | 4 | ||||
| -rw-r--r-- | include/opcode/ppc.h | 17 | ||||
| -rw-r--r-- | include/opcode/v850.h | 4 | ||||
| -rw-r--r-- | include/simple-object.h | 8 |
28 files changed, 2118 insertions, 233 deletions
diff --git a/include/ChangeLog b/include/ChangeLog index 8b25ce7..1ba7de3 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,187 @@ +2017-09-15 Pedro Alves <palves@redhat.com> + + Sync with mainline gcc sources (r252823) + + 2017-09-15 Yao Qi <yao.qi@linaro.org> + Pedro Alves <palves@redhat.com> + + * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. + + 2017-09-12 Jiong Wang <jiong.wang@arm.com> + + * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. + * dwarf2.h (DW_CFA_DUP): New define. + + 2017-08-21 Richard Biener <rguenther@suse.de> + + * simple-object.h (simple_object_copy_lto_debug_sections): New + function. + + 2017-05-18 Martin Liska <mliska@suse.cz> + + * ansidecl.h: Define CONSTEXPR macro. + + 2017-05-24 Nathan Sidwell <nathan@acm.org> + + * libiberty.h (ASTRDUP): Adjust cast to avoid warning. + + 2017-01-30 Alexandre Oliva <aoliva@redhat.com> + + Introduce C++ support in libcc1. + * gcc-c-fe.def (int_type_v0): Rename from... + (int_type): ... this. Introduce new version. + (float_type_v0): Rename from... + (float_type): ... this. Introduce new version. + (char_type): New. + * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. + (gcc_type_array): Move... + * gcc-interface.h: ... here. + * gcc-cp-fe.def: New. + * gcc-cp-interface.h: New. + + 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> + + * longlong.h (umul_ppmm): Remove SHMEDIA checks. + (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. + + 2017-09-15 Yao Qi <yao.qi@linaro.org> + Pedro Alves <palves@redhat.com> + + * ansidecl.h (DISABLE_COPY_AND_ASSIGN): New macro. + + 2017-09-12 Jiong Wang <jiong.wang@arm.com> + + * dwarf2.def (DW_CFA_AARCH64_negate_ra_state): New DW_CFA_DUP. + * dwarf2.h (DW_CFA_DUP): New define. + + 2017-08-21 Richard Biener <rguenther@suse.de> + + * simple-object.h (simple_object_copy_lto_debug_sections): New + function. + + 2017-05-18 Martin Liska <mliska@suse.cz> + + * ansidecl.h: Define CONSTEXPR macro. + + 2017-05-24 Nathan Sidwell <nathan@acm.org> + + * libiberty.h (ASTRDUP): Adjust cast to avoid warning. + + 2017-01-30 Alexandre Oliva <aoliva@redhat.com> + + Introduce C++ support in libcc1. + * gcc-c-fe.def (int_type_v0): Rename from... + (int_type): ... this. Introduce new version. + (float_type_v0): Rename from... + (float_type): ... this. Introduce new version. + (char_type): New. + * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. + (gcc_type_array): Move... + * gcc-interface.h: ... here. + * gcc-cp-fe.def: New. + * gcc-cp-interface.h: New. + + 2016-04-29 Oleg Endo <olegendo@gcc.gnu.org> + + * longlong.h (umul_ppmm): Remove SHMEDIA checks. + (__umulsidi3, count_leading_zeros): Remove SHMEDIA implementations. + +2017-09-06 Kamil Rytarowski <n54@gmx.com> + + * opcode/nds32.h: Rename __BIT() to N32_BIT(). + +2017-09-05 Alexander Fedotov <alexander.fedotov@nxp.com> + Edmar Wienskoski <edmar.wienskoski@nxp.com + + * elf/ppc.h (R_PPC_VLE_ADDR20): New relocation. + +2017-08-23 Alexander Fedotov <alexander.fedotov@nxp.com> + Edmar Wienskoski <edmar.wienskoski@nxp.com> + + * opcode/ppc.h: + (spe2_opcodes, spe2_num_opcodes): New. + (PPC_OPCODE_SPE2): New define. + (PPC_OPCODE_EFS2): Likewise. + (SPE2_XOP): Likewise. + (SPE2_XOP_TO_SEG): Likewise. + +2017-08-23 Jan Kratochvil <jan.kratochvil@redhat.com> + + * gcc-interface.h (enum gcc_base_api_version): Update comment for + GCC_FE_VERSION_1. + (struct gcc_base_vtable): Rename set_arguments to set_arguments_v0. + Add set_arguments, set_triplet_regexp and set_driver_filename. + +2017-08-23 Jan Kratochvil <jan.kratochvil@redhat.com> + + * gcc-interface.h (enum gcc_base_api_version): Add + GCC_FE_VERSION_1. + (struct gcc_base_vtable): Rename compile to compile_v0. Update + comment for compile. New methods set_verbose and compile. + +2017-08-21 Alexander Fedotov <alexander.fedotov@nxp.com> + Edmar Wienskoski <edmar.wienskoski@nxp.com> + + * opcode/ppc.h (PPC_OPCODE_LSP): New define. + +2017-08-14 Gustavo Romero <gromero@linux.vnet.ibm.com> + + * elf/common.h (NT_PPC_TAR): New macro. + (NT_PPC_PPR): Likewise. + (NT_PPC_DSCR): Likewise. + (NT_PPC_EBB): Likewise. + (NT_PPC_PMU): Likewise. + (NT_PPC_TM_CGPR): Likewise. + (NT_PPC_TM_CFPR): Likewise. + (NT_PPC_TM_CVMX): Likewise. + (NT_PPC_TM_CVSX): Likewise. + (NT_PPC_TM_SPR): Likewise. + (NT_PPC_TM_CTAR): Likewise. + (NT_PPC_TM_CPPR): Likewise. + (NT_PPC_TM_CDSCR): Likewise. + +2017-08-06 H.J. Lu <hongjiu.lu@intel.com> + + PR ld/21903: + * bfdlink.h (bfd_link_info): Add inhibit_common_definition. + +2017-07-31 Nick Clifton <nickc@redhat.com> + + PR 21850 + * ansidecl.h (OVERRIDE): Protect check of __cplusplus value with + #idef __cplusplus. + +2017-07-19 Claudiu Zissulescu <claziss@synopsys.com> + + * opcode/arc.h (SJLI): Add. + +2017-07-19 Claudiu Zissulescu <claziss@synopsys.com> + John Eric Martin <John.Martin@emmicro-us.com> + + * elf/arc-reloc.def: Add JLI relocs howto. + * opcode/arc-func.h (replace_jli): New function. + +2017-07-18 Nick Clifton <nickc@redhat.com> + + PR 21775 + * aout/adobe.h: Fix spelling typos. + * aout/aout64.h: Likewise. + * aout/hp300hpux.h: Likewise. + * elf/hppa.h: Likewise. + * gdb/remote-sim.h: Likewise. + * libiberty.h: Likewise. + * mach-o/arm.h: Likewise. + * opcode/v850.h: Likewise. + +2017-07-14 Ravi Bangoria <ravi.bangoria@linux.vnet.ibm.com> + + * dis-asm.h (struct disassemble_info): Change type of buffer_length + field to size_t. + +2017-07-07 John Baldwin <jhb@FreeBSD.org> + + * elf/common.h (NT_FREEBSD_PTLWPINFO): Define. + 2017-07-02 Jan Kratochvil <jan.kratochvil@redhat.com> * dwarf2.def (DW_IDX_compile_unit, DW_IDX_type_unit, DW_IDX_die_offset) diff --git a/include/ansidecl.h b/include/ansidecl.h index 6c0c837..450ce35 100644 --- a/include/ansidecl.h +++ b/include/ansidecl.h @@ -252,7 +252,7 @@ So instead we use the macro below and test it against specific values. */ # endif /* GNUC >= 3.0 */ #endif /* ATTRIBUTE_ALIGNED_ALIGNOF */ -/* Useful for structures whose layout must much some binary specification +/* Useful for structures whose layout must match some binary specification regardless of the alignment and padding qualities of the compiler. */ #ifndef ATTRIBUTE_PACKED # define ATTRIBUTE_PACKED __attribute__ ((packed)) @@ -313,6 +313,12 @@ So instead we use the macro below and test it against specific values. */ #define ENUM_BITFIELD(TYPE) unsigned int #endif +#if __cpp_constexpr >= 200704 +#define CONSTEXPR constexpr +#else +#define CONSTEXPR +#endif + /* C++11 adds the ability to add "override" after an implementation of a virtual function in a subclass, to: (A) document that this is an override of a virtual function @@ -328,26 +334,58 @@ So instead we use the macro below and test it against specific values. */ For gcc, use "-std=c++11" to enable C++11 support; gcc 6 onwards enables this by default (actually GNU++14). */ -#if __cplusplus >= 201103 -/* C++11 claims to be available: use it. final/override were only - implemented in 4.7, though. */ -# if GCC_VERSION < 4007 +#if defined __cplusplus +# if __cplusplus >= 201103 + /* C++11 claims to be available: use it. Final/override were only + implemented in 4.7, though. */ +# if GCC_VERSION < 4007 +# define OVERRIDE +# define FINAL +# else +# define OVERRIDE override +# define FINAL final +# endif +# elif GCC_VERSION >= 4007 + /* G++ 4.7 supports __final in C++98. */ # define OVERRIDE -# define FINAL +# define FINAL __final # else -# define OVERRIDE override -# define FINAL final + /* No C++11 support; leave the macros empty. */ +# define OVERRIDE +# define FINAL # endif -#elif GCC_VERSION >= 4007 -/* G++ 4.7 supports __final in C++98. */ -# define OVERRIDE -# define FINAL __final #else -/* No C++11 support; leave the macros empty: */ + /* No C++11 support; leave the macros empty. */ # define OVERRIDE # define FINAL #endif +/* A macro to disable the copy constructor and assignment operator. + When building with C++11 and above, the methods are explicitly + deleted, causing a compile-time error if something tries to copy. + For C++03, this just declares the methods, causing a link-time + error if the methods end up called (assuming you don't + define them). For C++03, for best results, place the macro + under the private: access specifier, like this, + + class name_lookup + { + private: + DISABLE_COPY_AND_ASSIGN (name_lookup); + }; + + so that most attempts at copy are caught at compile-time. */ + +#if __cplusplus >= 201103 +#define DISABLE_COPY_AND_ASSIGN(TYPE) \ + TYPE (const TYPE&) = delete; \ + void operator= (const TYPE &) = delete + #else +#define DISABLE_COPY_AND_ASSIGN(TYPE) \ + TYPE (const TYPE&); \ + void operator= (const TYPE &) +#endif /* __cplusplus >= 201103 */ + #ifdef __cplusplus } #endif diff --git a/include/aout/adobe.h b/include/aout/adobe.h index 9c26794..5e6cc8b 100644 --- a/include/aout/adobe.h +++ b/include/aout/adobe.h @@ -24,23 +24,23 @@ /* Struct external_exec is the same. */ -/* This is the layout on disk of the 32-bit or 64-bit exec header. */ +/* This is the layout on disk of the 32-bit or 64-bit exec header. */ struct external_exec { - bfd_byte e_info[4]; /* magic number and stuff */ - bfd_byte e_text[BYTES_IN_WORD]; /* length of text section in bytes */ - bfd_byte e_data[BYTES_IN_WORD]; /* length of data section in bytes */ - bfd_byte e_bss[BYTES_IN_WORD]; /* length of bss area in bytes */ - bfd_byte e_syms[BYTES_IN_WORD]; /* length of symbol table in bytes */ - bfd_byte e_entry[BYTES_IN_WORD]; /* start address */ - bfd_byte e_trsize[BYTES_IN_WORD]; /* length of text relocation info */ - bfd_byte e_drsize[BYTES_IN_WORD]; /* length of data relocation info */ + bfd_byte e_info[4]; /* Magic number and stuff. */ + bfd_byte e_text[BYTES_IN_WORD]; /* Length of text section in bytes. */ + bfd_byte e_data[BYTES_IN_WORD]; /* Length of data section in bytes. */ + bfd_byte e_bss[BYTES_IN_WORD]; /* Length of bss area in bytes. */ + bfd_byte e_syms[BYTES_IN_WORD]; /* Length of symbol table in bytes. */ + bfd_byte e_entry[BYTES_IN_WORD]; /* Start address. */ + bfd_byte e_trsize[BYTES_IN_WORD]; /* Length of text relocation info. */ + bfd_byte e_drsize[BYTES_IN_WORD]; /* Length of data relocation info. */ }; #define EXEC_BYTES_SIZE (4 + BYTES_IN_WORD * 7) -/* Magic numbers for a.out files */ +/* Magic numbers for a.out files. */ #undef ZMAGIC #define ZMAGIC 0xAD0BE /* Cute, eh? */ @@ -63,18 +63,20 @@ struct external_exec The actual text of the segments starts at N_TXTOFF in the file, regardless of how many or how few segment headers there are. */ -struct external_segdesc { - unsigned char e_type[1]; - unsigned char e_size[3]; - unsigned char e_virtbase[4]; - unsigned char e_filebase[4]; +struct external_segdesc +{ + unsigned char e_type[1]; + unsigned char e_size[3]; + unsigned char e_virtbase[4]; + unsigned char e_filebase[4]; }; -struct internal_segdesc { - unsigned int a_type:8; /* Segment type N_TEXT, N_DATA, 0 */ - unsigned int a_size:24; /* Segment size */ - bfd_vma a_virtbase; /* Virtual address */ - unsigned int a_filebase; /* Base address in object file */ +struct internal_segdesc +{ + unsigned int a_type:8; /* Segment type N_TEXT, N_DATA, 0. */ + unsigned int a_size:24; /* Segment size. */ + bfd_vma a_virtbase; /* Virtual address. */ + unsigned int a_filebase; /* Base address in object file. */ }; #define N_TXTADDR(x) is_this_really_unused? @@ -97,41 +99,43 @@ struct internal_segdesc { #define N_SYMOFF(x) ( N_DRELOFF(x) + (x)->a_drsize ) #define N_STROFF(x) ( N_SYMOFF(x) + (x)->a_syms ) -/* Symbols */ -struct external_nlist { - bfd_byte e_strx[BYTES_IN_WORD]; /* index into string table of name */ - bfd_byte e_type[1]; /* type of symbol */ - bfd_byte e_other[1]; /* misc info (usually empty) */ - bfd_byte e_desc[2]; /* description field */ - bfd_byte e_value[BYTES_IN_WORD]; /* value of symbol */ +/* Symbols. */ +struct external_nlist +{ + bfd_byte e_strx[BYTES_IN_WORD]; /* Index into string table of name. */ + bfd_byte e_type[1]; /* Type of symbol. */ + bfd_byte e_other[1]; /* Misc info (usually empty). */ + bfd_byte e_desc[2]; /* Description field. */ + bfd_byte e_value[BYTES_IN_WORD]; /* Value of symbol. */ }; #define EXTERNAL_NLIST_SIZE (BYTES_IN_WORD+4+BYTES_IN_WORD) -struct internal_nlist { - unsigned long n_strx; /* index into string table of name */ - unsigned char n_type; /* type of symbol */ - unsigned char n_other; /* misc info (usually empty) */ - unsigned short n_desc; /* description field */ - bfd_vma n_value; /* value of symbol */ +struct internal_nlist +{ + unsigned long n_strx; /* Index into string table of name. */ + unsigned char n_type; /* Type of symbol. */ + unsigned char n_other; /* Misc info (usually empty). */ + unsigned short n_desc; /* Description field. */ + bfd_vma n_value; /* Value of symbol. */ }; /* The n_type field is the symbol type, containing: */ -#define N_UNDF 0 /* Undefined symbol */ -#define N_ABS 2 /* Absolute symbol -- defined at particular addr */ -#define N_TEXT 4 /* Text sym -- defined at offset in text seg */ -#define N_DATA 6 /* Data sym -- defined at offset in data seg */ -#define N_BSS 8 /* BSS sym -- defined at offset in zero'd seg */ -#define N_COMM 0x12 /* Common symbol (visible after shared lib dynlink) */ -#define N_FN 0x1f /* File name of .o file */ -#define N_FN_SEQ 0x0C /* N_FN from Sequent compilers (sigh) */ +#define N_UNDF 0 /* Undefined symbol. */ +#define N_ABS 2 /* Absolute symbol -- defined at particular addr. */ +#define N_TEXT 4 /* Text sym -- defined at offset in text seg. */ +#define N_DATA 6 /* Data sym -- defined at offset in data seg. */ +#define N_BSS 8 /* BSS sym -- defined at offset in zero'd seg. */ +#define N_COMM 0x12 /* Common symbol (visible after shared lib dynlink). */ +#define N_FN 0x1f /* File name of .o file. */ +#define N_FN_SEQ 0x0C /* N_FN from Sequent compilers (sigh). */ /* Note: N_EXT can only be usefully OR-ed with N_UNDF, N_ABS, N_TEXT, N_DATA, or N_BSS. When the low-order bit of other types is set, (e.g. N_WARNING versus N_FN), they are two different types. */ -#define N_EXT 1 /* External symbol (as opposed to local-to-this-file) */ +#define N_EXT 1 /* External symbol (as opposed to local-to-this-file). */ #define N_TYPE 0x1e -#define N_STAB 0xe0 /* If any of these bits are on, it's a debug symbol */ +#define N_STAB 0xe0 /* If any of these bits are on, it's a debug symbol. */ #define N_INDR 0x0a @@ -147,10 +151,10 @@ struct internal_nlist { in that it can satisfy undefined external references. */ /* These appear as input to LD, in a .o file. */ -#define N_SETA 0x14 /* Absolute set element symbol */ -#define N_SETT 0x16 /* Text set element symbol */ -#define N_SETD 0x18 /* Data set element symbol */ -#define N_SETB 0x1A /* Bss set element symbol */ +#define N_SETA 0x14 /* Absolute set element symbol. */ +#define N_SETT 0x16 /* Text set element symbol. */ +#define N_SETD 0x18 /* Data set element symbol. */ +#define N_SETB 0x1A /* Bss set element symbol. */ /* This is output from LD. */ #define N_SETV 0x1C /* Pointer to set vector in data area. */ @@ -170,25 +174,25 @@ struct internal_nlist { instructions. Eg, on the 68k, each move instruction can reference the target with a displacement of 16 or 32 bits. On the sparc, move instructions use an offset of 14 bits, so the offset is stored in - the reloc field, and the data in the section is ignored. -*/ + the reloc field, and the data in the section is ignored. */ /* This structure describes a single relocation to be performed. The text-relocation section of the file is a vector of these structures, all of which apply to the text section. Likewise, the data-relocation section applies to the data section. */ -struct reloc_std_external { - bfd_byte r_address[BYTES_IN_WORD]; /* offset of of data to relocate */ - bfd_byte r_index[3]; /* symbol table index of symbol */ - bfd_byte r_type[1]; /* relocation type */ +struct reloc_std_external +{ + bfd_byte r_address[BYTES_IN_WORD]; /* Offset of data to relocate. */ + bfd_byte r_index[3]; /* Symbol table index of symbol. */ + bfd_byte r_type[1]; /* Relocation type. */ }; #define RELOC_STD_BITS_PCREL_BIG 0x80 #define RELOC_STD_BITS_PCREL_LITTLE 0x01 #define RELOC_STD_BITS_LENGTH_BIG 0x60 -#define RELOC_STD_BITS_LENGTH_SH_BIG 5 /* To shift to units place */ +#define RELOC_STD_BITS_LENGTH_SH_BIG 5 /* To shift to units place. */ #define RELOC_STD_BITS_LENGTH_LITTLE 0x06 #define RELOC_STD_BITS_LENGTH_SH_LITTLE 1 @@ -204,7 +208,7 @@ struct reloc_std_external { #define RELOC_STD_BITS_RELATIVE_BIG 0x02 #define RELOC_STD_BITS_RELATIVE_LITTLE 0x02 -#define RELOC_STD_SIZE (BYTES_IN_WORD + 3 + 1) /* Bytes per relocation entry */ +#define RELOC_STD_SIZE (BYTES_IN_WORD + 3 + 1) /* Bytes per relocation entry. */ struct reloc_std_internal { @@ -227,21 +231,22 @@ struct reloc_std_internal unsigned int r_extern:1; /* The next three bits are for SunOS shared libraries, and seem to be undocumented. */ - unsigned int r_baserel:1; /* Linkage table relative */ - unsigned int r_jmptable:1; /* pc-relative to jump table */ - unsigned int r_relative:1; /* "relative relocation" */ + unsigned int r_baserel:1; /* Linkage table relative. */ + unsigned int r_jmptable:1; /* pc-relative to jump table. */ + unsigned int r_relative:1; /* "relative relocation". */ /* unused */ - unsigned int r_pad:1; /* Padding -- set to zero */ + unsigned int r_pad:1; /* Padding -- set to zero. */ }; /* EXTENDED RELOCS */ -struct reloc_ext_external { - bfd_byte r_address[BYTES_IN_WORD]; /* offset of of data to relocate */ - bfd_byte r_index[3]; /* symbol table index of symbol */ - bfd_byte r_type[1]; /* relocation type */ - bfd_byte r_addend[BYTES_IN_WORD]; /* datum addend */ +struct reloc_ext_external +{ + bfd_byte r_address[BYTES_IN_WORD]; /* Offset of data to relocate. */ + bfd_byte r_index[3]; /* Symbol table index of symbol. */ + bfd_byte r_type[1]; /* Relocation type. */ + bfd_byte r_addend[BYTES_IN_WORD]; /* Datum addend. */ }; #define RELOC_EXT_BITS_EXTERN_BIG 0x80 @@ -257,15 +262,15 @@ struct reloc_ext_external { enum reloc_type { - /* simple relocations */ + /* Simple relocations. */ RELOC_8, /* data[0:7] = addend + sv */ RELOC_16, /* data[0:15] = addend + sv */ RELOC_32, /* data[0:31] = addend + sv */ - /* pc-rel displacement */ + /* PC-rel displacement. */ RELOC_DISP8, /* data[0:7] = addend - pc + sv */ RELOC_DISP16, /* data[0:15] = addend - pc + sv */ RELOC_DISP32, /* data[0:31] = addend - pc + sv */ - /* Special */ + /* Special. */ RELOC_WDISP30, /* data[0:29] = (addend + sv - pc)>>2 */ RELOC_WDISP22, /* data[0:21] = (addend + sv - pc)>>2 */ RELOC_HI22, /* data[0:21] = (addend + sv)>>10 */ @@ -274,16 +279,16 @@ enum reloc_type RELOC_LO10, /* data[0:9] = (addend + sv) */ RELOC_SFA_BASE, RELOC_SFA_OFF13, - /* P.I.C. (base-relative) */ - RELOC_BASE10, /* Not sure - maybe we can do this the */ - RELOC_BASE13, /* right way now */ + /* P.I.C. (base-relative). */ + RELOC_BASE10, /* Not sure - maybe we can do this the */ + RELOC_BASE13, /* right way now. */ RELOC_BASE22, - /* for some sort of pc-rel P.I.C. (?) */ + /* For some sort of pc-rel P.I.C. (?) */ RELOC_PC10, RELOC_PC22, - /* P.I.C. jump table */ + /* P.I.C. jump table. */ RELOC_JMP_TBL, - /* reputedly for shared libraries somehow */ + /* Reputedly for shared libraries somehow. */ RELOC_SEGOFF16, RELOC_GLOB_DAT, RELOC_JMP_SLOT, @@ -301,14 +306,14 @@ enum reloc_type RELOC_CONSTH, NO_RELOC - }; - +}; -struct reloc_internal { - bfd_vma r_address; /* offset of of data to relocate */ - long r_index; /* symbol table index of symbol */ - enum reloc_type r_type; /* relocation type */ - bfd_vma r_addend; /* datum addend */ +struct reloc_internal +{ + bfd_vma r_address; /* Offset of data to relocate. */ + long r_index; /* Symbol table index of symbol. */ + enum reloc_type r_type; /* Relocation type. */ + bfd_vma r_addend; /* Datum addend. */ }; -#endif /* __A_OUT_ADOBE_H__ */ +#endif /* __A_OUT_ADOBE_H__ */ diff --git a/include/aout/aout64.h b/include/aout/aout64.h index 6858ada..8c4ce3d 100644 --- a/include/aout/aout64.h +++ b/include/aout/aout64.h @@ -346,7 +346,7 @@ struct internal_nlist struct reloc_std_external { - bfd_byte r_address[BYTES_IN_WORD]; /* Offset of of data to relocate. */ + bfd_byte r_address[BYTES_IN_WORD]; /* Offset of data to relocate. */ bfd_byte r_index[3]; /* Symbol table index of symbol. */ bfd_byte r_type[1]; /* Relocation type. */ }; @@ -406,7 +406,7 @@ struct reloc_std_internal struct reloc_ext_external { - bfd_byte r_address[BYTES_IN_WORD]; /* Offset of of data to relocate. */ + bfd_byte r_address[BYTES_IN_WORD]; /* Offset of data to relocate. */ bfd_byte r_index[3]; /* Symbol table index of symbol. */ bfd_byte r_type[1]; /* Relocation type. */ bfd_byte r_addend[BYTES_IN_WORD]; /* Datum addend. */ @@ -501,7 +501,7 @@ enum reloc_type struct reloc_internal { - bfd_vma r_address; /* Offset of of data to relocate. */ + bfd_vma r_address; /* Offset of data to relocate. */ long r_index; /* Symbol table index of symbol. */ enum reloc_type r_type; /* Relocation type. */ bfd_vma r_addend; /* Datum addend. */ diff --git a/include/aout/hp300hpux.h b/include/aout/hp300hpux.h index b4fb000..6187a0e 100644 --- a/include/aout/hp300hpux.h +++ b/include/aout/hp300hpux.h @@ -38,47 +38,47 @@ struct hp300hpux_exec_bytes #define EXEC_BYTES_SIZE 64 struct hp300hpux_nlist_bytes - { - unsigned char e_value[4]; - unsigned char e_type[1]; - unsigned char e_length[1]; /* length of ascii symbol name */ - unsigned char e_almod[2]; /* alignment mod */ - unsigned char e_shlib[2]; /* info about dynamic linking */ - }; +{ + unsigned char e_value[4]; + unsigned char e_type[1]; + unsigned char e_length[1]; /* Length of ascii symbol name. */ + unsigned char e_almod[2]; /* Alignment mod. */ + unsigned char e_shlib[2]; /* Info about dynamic linking. */ +}; #define EXTERNAL_NLIST_SIZE 10 struct hp300hpux_reloc - { - unsigned char r_address[4];/* offset of of data to relocate */ - unsigned char r_index[2]; /* symbol table index of symbol */ - unsigned char r_type[1]; /* relocation type */ - unsigned char r_length[1]; /* length of item to reloc */ - }; +{ + unsigned char r_address[4];/* offset of data to relocate */ + unsigned char r_index[2]; /* symbol table index of symbol */ + unsigned char r_type[1]; /* relocation type */ + unsigned char r_length[1]; /* length of item to reloc */ +}; struct hp300hpux_header_extension { - unsigned char e_syms[4]; - unsigned char unique_headers[12*4]; - unsigned char e_header[2]; /* type of header */ - unsigned char e_version[2]; /* version */ - unsigned char e_size[4]; /* bytes following*/ - unsigned char e_extension[4];/* file offset of next extension */ + unsigned char e_syms[4]; + unsigned char unique_headers[12*4]; + unsigned char e_header[2]; /* Type of header. */ + unsigned char e_version[2]; /* Version. */ + unsigned char e_size[4]; /* Bytes following. */ + unsigned char e_extension[4];/* File offset of next extension. */ }; #define EXTERNAL_EXTENSION_HEADER_SIZE (16*4) -/* hpux separates object files (0x106) and impure executables (0x107) */ -/* but the bfd code does not distinguish between them. Since we want to*/ -/* read hpux .o files, we add an special define and use it below in */ -/* offset and address calculations. */ +/* HPUX separates object files (0x106) and impure executables (0x107) + but the bfd code does not distinguish between them. Since we want to + read hpux .o files, we add an special define and use it below in + offset and address calculations. */ #define HPUX_DOT_O_MAGIC 0x106 -#define OMAGIC 0x107 /* object file or impure executable. */ +#define OMAGIC 0x107 /* Object file or impure executable. */ #define NMAGIC 0x108 /* Code indicating pure executable. */ -#define ZMAGIC 0x10B /* demand-paged executable. */ +#define ZMAGIC 0x10B /* Demand-paged executable. */ #define N_HEADER_IN_TEXT(x) 0 -#if 0 /* libaout.h only uses the lower 8 bits */ +#if 0 /* libaout.h only uses the lower 8 bits. */ #define HP98x6_ID 0x20A #define HP9000S200_ID 0x20C #endif @@ -121,7 +121,7 @@ struct hp300hpux_header_extension #define N_EXTHOFF(x) ( N_DRELOFF(x) /* + (x)->a_drsize */) #define N_STROFF(x) ( 0 /* no string table */ ) -/* use these when the file has gnu symbol tables */ +/* Use these when the file has gnu symbol tables. */ #define N_GNU_TRELOFF(x) (N_DATOFF(x) + (x)->a_data) #define N_GNU_DRELOFF(x) (N_GNU_TRELOFF(x) + (x)->a_trsize) #define N_GNU_SYMOFF(x) (N_GNU_DRELOFF(x) + (x)->a_drsize) diff --git a/include/bfdlink.h b/include/bfdlink.h index e7c7836..2370c0d 100644 --- a/include/bfdlink.h +++ b/include/bfdlink.h @@ -489,6 +489,9 @@ struct bfd_link_info /* TRUE if generate a 1-byte NOP as suffix for x86 call instruction. */ unsigned int call_nop_as_suffix : 1; + /* TRUE if common symbols should be treated as undefined. */ + unsigned int inhibit_common_definition : 1; + /* The 1-byte NOP for x86 call instruction. */ char call_nop_byte; diff --git a/include/dis-asm.h b/include/dis-asm.h index 9b42514..4ff8bc9 100644 --- a/include/dis-asm.h +++ b/include/dis-asm.h @@ -158,7 +158,7 @@ typedef struct disassemble_info /* These are for buffer_read_memory. */ bfd_byte *buffer; bfd_vma buffer_vma; - unsigned int buffer_length; + size_t buffer_length; /* This variable may be set by the instruction decoder. It suggests the number of bytes objdump should display on a single line. If diff --git a/include/dwarf2.def b/include/dwarf2.def index 1d6d13b..8e731a3 100644 --- a/include/dwarf2.def +++ b/include/dwarf2.def @@ -780,6 +780,7 @@ DW_CFA (DW_CFA_MIPS_advance_loc8, 0x1d) /* GNU extensions. NOTE: DW_CFA_GNU_window_save is multiplexed on Sparc and AArch64. */ DW_CFA (DW_CFA_GNU_window_save, 0x2d) +DW_CFA_DUP (DW_CFA_AARCH64_negate_ra_state, 0x2d) DW_CFA (DW_CFA_GNU_args_size, 0x2e) DW_CFA (DW_CFA_GNU_negative_offset_extended, 0x2f) diff --git a/include/dwarf2.h b/include/dwarf2.h index c6d410e..fd76d82 100644 --- a/include/dwarf2.h +++ b/include/dwarf2.h @@ -52,6 +52,7 @@ #define DW_ATE(name, value) , name = value #define DW_ATE_DUP(name, value) , name = value #define DW_CFA(name, value) , name = value +#define DW_CFA_DUP(name, value) , name = value #define DW_IDX(name, value) , name = value #define DW_IDX_DUP(name, value) , name = value @@ -104,6 +105,7 @@ #undef DW_ATE #undef DW_ATE_DUP #undef DW_CFA +#undef DW_CFA_DUP #undef DW_IDX #undef DW_IDX_DUP diff --git a/include/elf/arc-reloc.def b/include/elf/arc-reloc.def index aa2309c..c58ca96 100644 --- a/include/elf/arc-reloc.def +++ b/include/elf/arc-reloc.def @@ -414,6 +414,13 @@ ARC_RELOC_HOWTO(ARC_S25H_PCREL_PLT, 61, \ signed, \ ( ME ( ( ( ( L + A ) - P ) >> 1 ) ) )) +ARC_RELOC_HOWTO(ARC_JLI_SECTOFF, 63, \ + 1, \ + 10, \ + replace_jli, \ + bitfield, \ + ( ( S - JLI ) >> 2)) + ARC_RELOC_HOWTO(ARC_TLS_DTPMOD, 66, \ 2, \ 32, \ diff --git a/include/elf/common.h b/include/elf/common.h index 2976c06..d08731c 100644 --- a/include/elf/common.h +++ b/include/elf/common.h @@ -570,6 +570,32 @@ /* note name must be "LINUX". */ #define NT_PPC_VSX 0x102 /* PowerPC VSX registers */ /* note name must be "LINUX". */ +#define NT_PPC_TAR 0x103 /* PowerPC Target Address Register */ + /* note name must be "LINUX". */ +#define NT_PPC_PPR 0x104 /* PowerPC Program Priority Register */ + /* note name must be "LINUX". */ +#define NT_PPC_DSCR 0x105 /* PowerPC Data Stream Control Register */ + /* note name must be "LINUX". */ +#define NT_PPC_EBB 0x106 /* PowerPC Event Based Branch Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_PMU 0x107 /* PowerPC Performance Monitor Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CGPR 0x108 /* PowerPC TM checkpointed GPR Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CFPR 0x109 /* PowerPC TM checkpointed FPR Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CVMX 0x10a /* PowerPC TM checkpointed VMX Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CVSX 0x10b /* PowerPC TM checkpointed VSX Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_SPR 0x10c /* PowerPC TM Special Purpose Registers */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CTAR 0x10d /* PowerPC TM checkpointed TAR */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CPPR 0x10e /* PowerPC TM checkpointed PPR */ + /* note name must be "LINUX". */ +#define NT_PPC_TM_CDSCR 0x10f /* PowerPC TM checkpointed Data SCR */ + /* note name must be "LINUX". */ #define NT_386_TLS 0x200 /* x86 TLS information */ /* note name must be "LINUX". */ #define NT_386_IOPERM 0x201 /* x86 io permissions */ @@ -641,6 +667,7 @@ #define NT_FREEBSD_PROCSTAT_OSREL 14 /* Procstat osreldate data. */ #define NT_FREEBSD_PROCSTAT_PSSTRINGS 15 /* Procstat ps_strings data. */ #define NT_FREEBSD_PROCSTAT_AUXV 16 /* Procstat auxv data. */ +#define NT_FREEBSD_PTLWPINFO 17 /* Thread ptrace miscellaneous info. */ /* Note segments for core files on NetBSD systems. Note name must start with "NetBSD-CORE". */ diff --git a/include/elf/hppa.h b/include/elf/hppa.h index 77822cc..99beb42 100644 --- a/include/elf/hppa.h +++ b/include/elf/hppa.h @@ -138,7 +138,7 @@ RELOC_NUMBER (R_PARISC_DIR14F, 7) When supporting argument relocations, function calls must be accompanied by parameter relocation information. This information is carried in the ten high-order bits of the addend field. The remaining - 22 bits of of the addend field are sign-extended to form the Addend. + 22 bits of the addend field are sign-extended to form the Addend. Note the code to build argument relocations depends on the addend being zero. A consequence of this limitation is GAS diff --git a/include/elf/ppc.h b/include/elf/ppc.h index 6790cd7..a7d2f3e 100644 --- a/include/elf/ppc.h +++ b/include/elf/ppc.h @@ -152,6 +152,7 @@ START_RELOC_NUMBERS (elf_ppc_reloc_type) RELOC_NUMBER (R_PPC_VLE_SDAREL_HI16D, 230) RELOC_NUMBER (R_PPC_VLE_SDAREL_HA16A, 231) RELOC_NUMBER (R_PPC_VLE_SDAREL_HA16D, 232) + RELOC_NUMBER (R_PPC_VLE_ADDR20, 233) /* Power9 split rel16 for addpcis. */ RELOC_NUMBER (R_PPC_REL16DX_HA, 246) diff --git a/include/gcc-c-fe.def b/include/gcc-c-fe.def index 09998ba..acf1940 100644 --- a/include/gcc-c-fe.def +++ b/include/gcc-c-fe.def @@ -125,16 +125,18 @@ GCC_METHOD3 (gcc_type, build_function_type, const struct gcc_type_array *, /* Argument ARGUMENT_TYPES. */ int /* bool */) /* Argument IS_VARARGS. */ -/* Return an integer type with the given properties. */ +/* Return an integer type with the given properties. + Deprecated in v1, use int_type instead. */ -GCC_METHOD2 (gcc_type, int_type, +GCC_METHOD2 (gcc_type, int_type_v0, int /* bool */, /* Argument IS_UNSIGNED. */ unsigned long) /* Argument SIZE_IN_BYTES. */ -/* Return a floating point type with the given properties. */ +/* Return a floating point type with the given properties. + Deprecated in v1, use float_type instead. */ -GCC_METHOD1 (gcc_type, float_type, - unsigned long) /* Argument SIZE_IN_BYTES. */ +GCC_METHOD1 (gcc_type, float_type_v0, + unsigned long) /* Argument SIZE_IN_BYTES. */ /* Return the 'void' type. */ @@ -195,3 +197,26 @@ GCC_METHOD5 (int /* bool */, build_constant, GCC_METHOD1 (gcc_type, error, const char *) /* Argument MESSAGE. */ + +/* Return an integer type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD3 (gcc_type, int_type, + int /* bool */, /* Argument IS_UNSIGNED. */ + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + +/* Return the 'char' type, a distinct type from both 'signed char' and + 'unsigned char' returned by int_type. */ + +GCC_METHOD0 (gcc_type, char_type) + +/* Return a floating point type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD2 (gcc_type, float_type, + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + diff --git a/include/gcc-c-interface.h b/include/gcc-c-interface.h index 00ccbfb..e048c86 100644 --- a/include/gcc-c-interface.h +++ b/include/gcc-c-interface.h @@ -41,7 +41,11 @@ struct gcc_c_context; enum gcc_c_api_version { - GCC_C_FE_VERSION_0 = 0 + GCC_C_FE_VERSION_0 = 0, + + /* Added char_type. Added new version of int_type and float_type, + deprecated int_type_v0 and float_type_v0. */ + GCC_C_FE_VERSION_1 = 1 }; /* Qualifiers. */ @@ -111,19 +115,6 @@ typedef gcc_address gcc_c_symbol_address_function (void *datum, struct gcc_c_context *ctxt, const char *identifier); -/* An array of types used for creating a function type. */ - -struct gcc_type_array -{ - /* Number of elements. */ - - int n_elements; - - /* The elements. */ - - gcc_type *elements; -}; - /* The vtable used by the C front end. */ struct gcc_c_fe_vtable @@ -146,7 +137,7 @@ struct gcc_c_fe_vtable provides the declaration. DATUM is an arbitrary piece of data that is passed back verbatim - to the callbakcs in requests. */ + to the callbacks in requests. */ void (*set_callbacks) (struct gcc_c_context *self, gcc_c_oracle_function *binding_oracle, diff --git a/include/gcc-cp-fe.def b/include/gcc-cp-fe.def new file mode 100644 index 0000000..c367c1d --- /dev/null +++ b/include/gcc-cp-fe.def @@ -0,0 +1,1050 @@ +/* Interface between GCC C++ FE and GDB -*- c -*- + + Copyright (C) 2014-2017 Free Software Foundation, Inc. + + This file is part of GCC. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + + + +/* Push namespace NAME as the current binding level, to which + newly-introduced decls will be bound. An empty string identifies + the global namespace, whereas NULL identifies an anonymous + namespace. A namespace named NAME is created in the current scope, + if needed. + + If the newly-created namespace is to be an inline namespace, see + make_namespace_inline. */ + +GCC_METHOD1 (int /* bool */, push_namespace, + const char *) /* Argument NAME. */ + +/* Push TYPE as the current binding level, making its members visible + for name lookup. The current scope before the call must be the + scope in which the class was declared. This should be used if the + definition of a class is already finished, but one wishes to define + a nested class, or to enter the scope of one of its member + functions. */ + +GCC_METHOD1 (int /* bool */, push_class, + gcc_type) /* Argument TYPE. */ + +/* Push FUNCTION_DECL as the current (empty) binding level (see + reactivate_decl). The current enclosing scope before the call must + be the scope in which the function was declared. */ + +GCC_METHOD1 (int /* bool */, push_function, + gcc_decl) /* Argument FUNCTION_DECL. */ + +/* Make DECL visible (again?) within SCOPE. When SCOPE is NULL, it + means the current scope; if it is not NULL, it must name a function + that is currently active, even if not at the top of the binding + chain. + + This function can be used to make e.g. a global function or + variable visible in a namespace or local scope (overriding another + enclosing definition of the same name), but its most common + expected use of this primitive, that gives it its name, is to make + declarations visible again after reentering a function scope, + because when a function is entered with push_function, that does + NOT make any of the declarations nested in it visible for name + lookup. + + There is a reason/excuse for that: unlike namespaces and classes, + G++ doesn't ever have to reenter function scopes, so its name + resolution infrastructure is not prepared to do that. But wait, + there is also a good use for this apparent limitation: a function + may contain multiple scopes (blocks), and the name may be bound to + different symbols in each of these scopes. With this interface, as + we reenter a function scope, we may choose which symbols to make + visible for the code snippet, or, if there could be template + functions in local scopes, for unresolved names in nested template + class default arguments, or in nested template function signatures. + + As for making a local declaration visible for the code snippet, + there are two possibilities: a) introduce it upfront, while + entering the scope for the user expression (see the enter_scope + callback, called by g++ when encountering the push_user_expression + pragma), which might save some scope switching and reactivate_decl + (though this can't be helped if some declarations have to be + introduced and discarded, because of multiple definitions of the + same name in different scopes within a function: they have to be + defined in discriminator order); or b) introduce it when its name + is looked up, entering the scope, introducing the declaration, + leaving the scope, and then reactivating the declaration in its + local scope. + + Here's some more detail on how reactivate_decl works. Say there's + a function foo whose body looks like this: + + { + { +// point 1 + class c {} o __attribute__ ((__used__)); // c , o + } + struct c { + void f() { +// point 2 + } + } o __attribute__ ((__used__)); // c_0, o_0 + { + class c {} p __attribute__ ((__used__)); // c_1, p +// point 3 + o.f(); + } + } + + When we are about to define class c at point 1, we enter the + function foo scope, and since no symbols are visible at point 1, we + proceed to declare class c. We may then define the class right + away, or, if we leave the function scope, and we later wish to + define it, or to define object o, we can reenter the scope and just + use the previously-obtained gcc_decl to define the class, without + having to reactivate the declaration. + + Now, if we are to set up the binding context for point 2, we have + to define c_0::f, and in order to do so, we have to declare and + define c_0. Before we can declare c_0, we MUST at least declare c. + + As a general rule, before we can declare or define any local name + with a discriminator, we have to at least declare any other + occurrences of the same name in the same enclosing entity with + lower or absent discriminator. + + So, we declare c, then we leave the function scope and reenter it + so as to declare c_0 (also with name "c", which is why we have to + leave and reenter the function scope, otherwise we would get an + error because of the duplicate definition; g++ will assign a + discriminator because it still remembers there was an earlier + declaration of c_0 within the function, it's just no longer in + scope), then we can define c_0, including its member function f. + + Likewise, if we wish to define o_0, we have to define o first. If + we wish to declare (and maybe then define) c_1, we have to at least + declare (c and then) c_0 first. + + Then, as we set up the binding context to compile a code snippet at + point 3, we may choose to activate c_1, o_0 and p upfront, + declaring and discarding c, c_0 and o, and then reentering the + funciton scope to declare c_1, o_0 and p; or we can wait for oracle + lookups of c, o or p. If c is looked up, and the debugger resolves + c in the scope to c_1, it is expected to enter the function scope + from the top level, declare c, leave it, reenter it, declare c_0, + leave it, reenter it, declare c_1, leave it, and then reactivate + c_1 in the function scope. If c_1 is needed as a complete type, + the definition may be given right after the declaration, or the + scope will have to be reentered in order to define the class. + +. If the code snippet is at point 2, we don't need to (re)activate + any declaration: nothing from any local scope is visible. Just + entering the scope of the class containing member function f + reactivates the names of its members, including the class name + itself. */ + +GCC_METHOD2 (int /* bool */, reactivate_decl, + gcc_decl, /* Argument DECL. */ + gcc_decl) /* Argument SCOPE. */ + +/* Pop the namespace last entered with push_namespace, or class last + entered with push_class, or function last entered with + push_function, restoring the binding level in effect before the + matching push_* call. */ + +GCC_METHOD0 (int /* bool */, pop_binding_level) + +/* Return the NAMESPACE_DECL, TYPE_DECL or FUNCTION_DECL of the + binding level that would be popped by pop_scope. */ + +GCC_METHOD0 (gcc_decl, get_current_binding_level_decl) + +/* Make the current binding level an inline namespace. It must be a + namespace to begin with. It is safe to call this more than once + for the same namespace, but after the first call, subsequent ones + will not return a success status. */ + +GCC_METHOD0 (int /* bool */, make_namespace_inline) + +/* Add USED_NS to the namespaces used by the current binding level. + Use get_current_binding_level_decl to obtain USED_NS's + gcc_decl. */ + +GCC_METHOD1 (int /* bool */, add_using_namespace, + gcc_decl) /* Argument USED_NS. */ + +/* Introduce a namespace alias declaration, as in: + + namespace foo = [... ::] bar; + + After this call, namespace TARGET will be visible as ALIAS within + the current namespace. Get the declaration for TARGET by calling + get_current_binding_level_decl after pushing into it. */ + +GCC_METHOD2 (int /* bool */, add_namespace_alias, + const char *, /* Argument ALIAS. */ + gcc_decl) /* Argument TARGET. */ + +/* Introduce a using declaration, as in: + + using foo::bar; + + The TARGET decl names the qualifying scope (foo:: above) and the + identifier (bar), but that does not mean that only TARGET will be + brought into the current scope: all bindings of TARGET's identifier + in the qualifying scope will be brought in. + + FLAGS should specify GCC_CP_SYMBOL_USING. If the current scope is + a class scope, visibility flags must be supplied. + + Even when TARGET is template dependent, we don't need to specify + whether or not it is a typename: the supplied declaration (that + could be a template-dependent type converted to declaration by + get_type_decl) indicates so. */ + +GCC_METHOD2 (int /* bool */, add_using_decl, + enum gcc_cp_symbol_kind, /* Argument FLAGS. */ + gcc_decl) /* Argument TARGET. */ + +/* Create a new "decl" in GCC, and bind it in the current binding + level. A decl is a declaration, basically a kind of symbol. + + NAME is the name of the new symbol. SYM_KIND is the kind of + symbol being requested. SYM_TYPE is the new symbol's C++ type; + except for labels, where this is not meaningful and should be + zero. If SUBSTITUTION_NAME is not NULL, then a reference to this + decl in the source will later be substituted with a dereference + of a variable of the given name. Otherwise, for symbols having + an address (e.g., functions), ADDRESS is the address. FILENAME + and LINE_NUMBER refer to the symbol's source location. If this + is not known, FILENAME can be NULL and LINE_NUMBER can be 0. + This function returns the new decl. + + Use this function to register typedefs, functions and variables to + namespace and local binding levels, and typedefs, member functions + (static or not), and static data members to class binding levels. + Class members must have their access controls specified with + GCC_CP_ACCESS_* flags in SYM_KIND. + + Note that, since access controls are disabled, we have no means to + express private, protected and public. + + There are various flags that can be set in SYM_KIND to specify + additional semantics. Look for GCC_CP_FLAGs in the definition of + enum gcc_cp_symbol_kind in gcc-cp-interface.h. + + In order to define member functions, pass GCC_CP_SYMBOL_FUNCTION in + SYM_KIND, and a function_type for static member functions or a + method type for non-static member functions, including constructors + and destructors. Use build_function_type to create a function + type; for a method type, start by creating a function type without + any compiler-introduced artificial arguments (the implicit this + pointer, and the __in_chrg added to constructors and destructors, + and __vtt_parm added to the former), and then use build_method_type + to create the method type out of the class type and the function + type. + + For operator functions, set GCC_CP_FLAG_SPECIAL_FUNCTION in + SYM_KIND, in addition to any other applicable flags, and pass as + NAME a string starting with the two-character mangling for operator + name: "ps" for unary plus, "mL" for multiply and assign, *=; etc. + Use "cv" for type converstion operators (the target type portion + may be omitted, as it is taken from the return type in SYM_TYPE). + For operator"", use "li" followed by the identifier (the mangled + name mandates digits specifying the length of the identifier; if + present, they determine the end of the identifier, otherwise, the + identifier extents to the end of the string, so that "li3_Kme" and + "li_Km" are equivalent). + + Constructors and destructors need special care, because for each + constructor and destructor there may be multiple clones defined + internally by the compiler. With build_decl, you can introduce the + base declaration of a constructor or a destructor, setting + GCC_CP_FLAG_SPECIAL_FUNCTION the flag and using names starting with + capital "C" or "D", respectively, followed by a digit (see below), + a blank, or NUL ('\0'). DO NOT supply an ADDRESS or a + SUBSTITUTION_NAME to build_decl, it would be meaningless (and + rejected) for the base declaration; use define_cdtor_clone to + introduce the address of each clone. For constructor templates, + declare the template with build_decl, and then, for each + specialization, introduce it with + build_function_template_specialization, and then define the + addresses of each of its clones with define_cdtor_clone. + + NAMEs for GCC_CP_FLAG_SPECIAL_FUNCTION: + + NAME meaning + C? constructor base declaration (? may be 1, 2, 4, blank or NUL) + D? destructor base declaration (? may be 0, 1, 2, 4, blank or NUL) + nw operator new + na operator new[] + dl operator delete + da operator delete[] + ps operator + (unary) + ng operator - (unary) + ad operator & (unary) + de operator * (unary) + co operator ~ + pl operator + + mi operator - + ml operator * + dv operator / + rm operator % + an operator & + or operator | + eo operator ^ + aS operator = + pL operator += + mI operator -= + mL operator *= + dV operator /= + rM operator %= + aN operator &= + oR operator |= + eO operator ^= + ls operator << + rs operator >> + lS operator <<= + rS operator >>= + eq operator == + ne operator != + lt operator < + gt operator > + le operator <= + ge operator >= + nt operator ! + aa operator && + oo operator || + pp operator ++ + mm operator -- + cm operator , + pm operator ->* + pt operator -> + cl operator () + ix operator [] + qu operator ? + cv operator <T> (conversion operator) + li<id> operator "" <id> + + FIXME: How about attributes? */ + +GCC_METHOD7 (gcc_decl, build_decl, + const char *, /* Argument NAME. */ + enum gcc_cp_symbol_kind, /* Argument SYM_KIND. */ + gcc_type, /* Argument SYM_TYPE. */ + const char *, /* Argument SUBSTITUTION_NAME. */ + gcc_address, /* Argument ADDRESS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Supply the ADDRESS of one of the multiple clones of constructor or + destructor CDTOR. The clone is specified by NAME, using the + following name mangling conventions: + + C1 in-charge constructor + C2 not-in-charge constructor + C4 unified constructor + D0 deleting destructor + D1 in-charge destructor + D2 not-in-charge destructor + D4 unified destructor + + The following information is not necessary to use the API. + + C1 initializes an instance of the class (rather than of derived + classes), including virtual base classes, whereas C2 initializes a + sub-object (of the given class type) of an instance of some derived + class (or a full object that doesn't have any virtual base + classes). + + D0 and D1 destruct an instance of the class, including virtual base + classes, but only the former calls operator delete to release the + object's storage at the end; D2 destructs a sub-object (of the + given class type) of an instance of a derived class (or a full + object that doesn't have any virtual base classes). + + The [CD]4 manglings (and symbol definitions) are non-standard, but + GCC uses them in some cases: rather than assuming they are + in-charge or not-in-charge, they test the implicit argument that + the others ignore to tell how to behave. These are used instead of + cloning when we just can't use aliases. */ + +GCC_METHOD3 (gcc_decl, define_cdtor_clone, + const char *, /* Argument NAME. */ + gcc_decl, /* Argument CDTOR. */ + gcc_address) /* Argument ADDRESS. */ + +/* Return the type associated with the given declaration. This is + most useful to obtain the type associated with a forward-declared + class, because it is the gcc_type, rather than the gcc_decl, that + has to be used to build other types, but build_decl returns a + gcc_decl rather than a gcc_type. This call can in theory be used + to obtain the type from any other declaration; it is supposed to + return the same type that was supplied when the declaration was + created. */ + +GCC_METHOD1 (gcc_type, get_decl_type, + gcc_decl) /* Argument DECL. */ + +/* Return the declaration for a type. */ + +GCC_METHOD1 (gcc_decl, get_type_decl, + gcc_type) /* Argument TYPE. */ + +/* Declare DECL as a friend of the current class scope, if TYPE is + NULL, or of TYPE itself otherwise. DECL may be a function or a + class, be they template generics, template specializations or not + templates. TYPE must be a class type (not a template generic). + + The add_friend call cannot introduce a declaration; even if the + friend is first declared as a friend in the source code, the + declaration belongs in the enclosing namespace, so it must be + introduced in that namespace, and the resulting declaration can + then be made a friend. + + DECL cannot, however, be a member of a template class generic, + because we have no means to introduce their declarations. This + interface has no notion of definitions for template generics. As a + consequence, users of this interface must introduce each friend + template member specialization separately, i.e., instead of: + + template <typename T> friend struct X<T>::M; + + they must be declared as if they were: + + friend struct X<onetype>::M; + friend struct X<anothertype>::M; + ... for each specialization of X. + + + Specializations of a template can have each others' members as + friends: + + template <typename T> class foo { + int f(); + template <typename U> friend int foo<U>::f(); + }; + + It wouldn't always be possible to define all specializations of a + template class before introducing the friend declarations in their + expanded, per-specialization form. + + In order to simplify such friend declarations, and to enable + incremental friend declarations as template specializations are + introduced, add_friend can be called after the befriending class is + fully defined, passing it a non-NULL TYPE argument naming the + befriending class type. */ + +GCC_METHOD2 (int /* bool */, add_friend, + gcc_decl, /* Argument DECL. */ + gcc_type) /* Argument TYPE. */ + +/* Return the type of a pointer to a given base type. */ + +GCC_METHOD1 (gcc_type, build_pointer_type, + gcc_type) /* Argument BASE_TYPE. */ + +/* Return the type of a reference to a given base type. */ + +GCC_METHOD2 (gcc_type, build_reference_type, + gcc_type, /* Argument BASE_TYPE. */ + enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ + +/* Create a new pointer-to-member type. MEMBER_TYPE is the data + member type, while CLASS_TYPE is the class type containing the data + member. For pointers to member functions, MEMBER_TYPE must be a + method type, and CLASS_TYPE must be specified even though it might + be possible to extract it from the method type. */ + +GCC_METHOD2 (gcc_type, build_pointer_to_member_type, + gcc_type, /* Argument CLASS_TYPE. */ + gcc_type) /* Argument MEMBER_TYPE. */ + +/* Start a template parameter list scope and enters it, so that + subsequent build_type_template_parameter and + build_value_template_parameter calls create template parameters in + the list. The list is closed by a build_decl call with + GCC_CP_SYMBOL_FUNCTION or GCC_CP_SYMBOL_CLASS, that, when the scope + is a template parameter list, declares a template function or a + template class with the then-closed parameter list. The scope in + which the new declaration is to be introduced by build_decl must be + entered before calling start_template_decl, and build_decl returns + to that scope, from the template parameter list scope, before + introducing the declaration. */ + +GCC_METHOD0 (int /* bool */, start_template_decl) + +/* Build a typename template-parameter (e.g., the T in template + <typename T = X>). Either PACK_P should be nonzero, to indicate an + argument pack (the last argument in a variadic template argument + list, as in template <typename... T>), or DEFAULT_TYPE may be + non-NULL to set the default type argument (e.g. X) for the template + parameter. FILENAME and LINE_NUMBER may specify the source + location in which the template parameter was declared. */ + +GCC_METHOD5 (gcc_type, build_type_template_parameter, + const char *, /* Argument ID. */ + int /* bool */, /* Argument PACK_P. */ + gcc_type, /* Argument DEFAULT_TYPE. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Build a template template-parameter (e.g., the T in template + <template <[...]> class T = X>). DEFAULT_TEMPL may be non-NULL to + set the default type-template argument (e.g. X) for the template + template parameter. FILENAME and LINE_NUMBER may specify the + source location in which the template parameter was declared. */ + +GCC_METHOD5 (gcc_utempl, build_template_template_parameter, + const char *, /* Argument ID. */ + int /* bool */, /* Argument PACK_P. */ + gcc_utempl, /* Argument DEFAULT_TEMPL. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Build a value template-parameter (e.g., the V in template <typename + T, T V> or in template <int V = X>). DEFAULT_VALUE may be non-NULL + to set the default value argument for the template parameter (e.g., + X). FILENAME and LINE_NUMBER may specify the source location in + which the template parameter was declared. */ + +GCC_METHOD5 (gcc_decl, build_value_template_parameter, + gcc_type, /* Argument TYPE. */ + const char *, /* Argument ID. */ + gcc_expr, /* Argument DEFAULT_VALUE. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Build a template-dependent typename (e.g., typename T::bar or + typename T::template bart<X>). ENCLOSING_TYPE should be the + template-dependent nested name specifier (e.g., T), ID should be + the name of the member of the ENCLOSING_TYPE (e.g., bar or bart), + and TARGS should be non-NULL and specify the template arguments + (e.g. <X>) iff ID is to name a class template. + + In this and other calls, a template-dependent nested name specifier + may be a template class parameter (build_type_template_parameter), + a specialization (returned by build_dependent_type_template_id) of + a template template parameter (returned by + build_template_template_parameter) or a member type thereof + (returned by build_dependent_typename itself). */ + +GCC_METHOD3 (gcc_type, build_dependent_typename, + gcc_type, /* Argument ENCLOSING_TYPE. */ + const char *, /* Argument ID. */ + const struct gcc_cp_template_args *) /* Argument TARGS. */ + +/* Build a template-dependent class template (e.g., T::template bart). + ENCLOSING_TYPE should be the template-dependent nested name + specifier (e.g., T), ID should be the name of the class template + member of the ENCLOSING_TYPE (e.g., bart). */ + +GCC_METHOD2 (gcc_utempl, build_dependent_class_template, + gcc_type, /* Argument ENCLOSING_TYPE. */ + const char *) /* Argument ID. */ + +/* Build a template-dependent type template-id (e.g., T<A>). + TEMPLATE_DECL should be a template template parameter (e.g., the T + in template <template <[...]> class T = X>), and TARGS should + specify the template arguments (e.g. <A>). */ + +GCC_METHOD2 (gcc_type, build_dependent_type_template_id, + gcc_utempl, /* Argument TEMPLATE_DECL. */ + const struct gcc_cp_template_args *) /* Argument TARGS. */ + +/* Build a template-dependent expression (e.g., S::val or S::template + mtf<X>, or unqualified f or template tf<X>). + + ENCLOSING_SCOPE should be a template-dependent nested name + specifier (e.g., T), a resolved namespace or class decl, or NULL + for unqualified names; ID should be the name of the member of the + ENCLOSING_SCOPE (e.g., val or mtf) or unqualified overloaded + function; and TARGS should list template arguments (e.g. <X>) when + mtf or tf are to name a template function, or be NULL otherwise. + + Unqualified names and namespace- or class-qualified names can only + resolve to overloaded functions, to be used in contexts that + involve overload resolution that cannot be resolved because of + template-dependent argument or return types, such as call + expressions with template-dependent arguments, conversion + expressions to function types with template-dependent argument + types or the like. Other cases of unqualified or + non-template-dependent-qualified names should NOT use this + function, and use decl_expr to convert the appropriate function or + object declaration to an expression. + + If ID is the name of a special member function, FLAGS should be + GCC_CP_SYMBOL_FUNCTION|GCC_CP_FLAG_SPECIAL_FUNCTION, and ID should + be one of the encodings for special member functions documented in + build_decl. Otherwise, FLAGS should be GCC_CP_SYMBOL_MASK, which + suggests the symbol kind is not known (though we know it is not a + type). + + If ID denotes a conversion operator, CONV_TYPE should name the + target type of the conversion. Otherwise, CONV_TYPE must be + NULL. */ + +GCC_METHOD5 (gcc_expr, build_dependent_expr, + gcc_decl, /* Argument ENCLOSING_SCOPE. */ + enum gcc_cp_symbol_kind, /* Argument FLAGS. */ + const char *, /* Argument NAME. */ + gcc_type, /* Argument CONV_TYPE. */ + const struct gcc_cp_template_args *) /* Argument TARGS. */ + +/* Build a gcc_expr for the value VALUE in type TYPE. */ + +GCC_METHOD2 (gcc_expr, build_literal_expr, + gcc_type, /* Argument TYPE. */ + unsigned long) /* Argument VALUE. */ + +/* Build a gcc_expr that denotes DECL, the declaration of a variable + or function in namespace scope, or of a static member variable or + function. Use QUALIFIED_P to build the operand of unary & so as to + compute a pointer-to-member, rather than a regular pointer. */ + +GCC_METHOD2 (gcc_expr, build_decl_expr, + gcc_decl, /* Argument DECL. */ + int /* bool */) /* Argument QUALIFIED_P. */ + +/* Build a gcc_expr that denotes the unary operation UNARY_OP applied + to the gcc_expr OPERAND. For non-expr operands, see + unary_type_expr. Besides the UNARY_OP encodings used for operator + names, we support "pp_" for preincrement, and "mm_" for + predecrement, "nx" for noexcept, "tw" for throw, "tr" for rethrow + (pass NULL as the operand), "te" for typeid, "sz" for sizeof, "az" + for alignof, "dl" for delete, "gsdl" for ::delete, "da" for + delete[], "gsda" for ::delete[], "sp" for pack expansion, "sZ" for + sizeof...(function argument pack). */ + +GCC_METHOD2 (gcc_expr, build_unary_expr, + const char *, /* Argument UNARY_OP. */ + gcc_expr) /* Argument OPERAND. */ + +/* Build a gcc_expr that denotes the binary operation BINARY_OP + applied to gcc_exprs OPERAND1 and OPERAND2. Besides the BINARY_OP + encodings used for operator names, we support "ds" for the operator + token ".*" and "dt" for the operator token ".". When using + operators that take a name as their second operand ("." and "->") + use decl_expr to convert the gcc_decl of the member name to a + gcc_expr, if the member name wasn't created with + e.g. build_dependent_expr. */ + +GCC_METHOD3 (gcc_expr, build_binary_expr, + const char *, /* Argument BINARY_OP. */ + gcc_expr, /* Argument OPERAND1. */ + gcc_expr) /* Argument OPERAND2. */ + +/* Build a gcc_expr that denotes the ternary operation TERNARY_OP + applied to gcc_exprs OPERAND1, OPERAND2 and OPERAND3. The only + supported TERNARY_OP is "qu", for the "?:" operator. */ + +GCC_METHOD4 (gcc_expr, build_ternary_expr, + const char *, /* Argument TERNARY_OP. */ + gcc_expr, /* Argument OPERAND1. */ + gcc_expr, /* Argument OPERAND2. */ + gcc_expr) /* Argument OPERAND3. */ + +/* Build a gcc_expr that denotes the unary operation UNARY_OP applied + to the gcc_type OPERAND. Supported unary operations taking types + are "ti" for typeid, "st" for sizeof, "at" for alignof, and "sZ" + for sizeof...(template argument pack). */ + +GCC_METHOD2 (gcc_expr, build_unary_type_expr, + const char *, /* Argument UNARY_OP. */ + gcc_type) /* Argument OPERAND. */ + +/* Build a gcc_expr that denotes the binary operation BINARY_OP + applied to gcc_type OPERAND1 and gcc_expr OPERAND2. Use this for + all kinds of (single-argument) type casts ("dc", "sc", "cc", "rc" + for dynamic, static, const and reinterpret casts, respectively; + "cv" for functional or C-style casts). */ + +GCC_METHOD3 (gcc_expr, build_cast_expr, + const char *, /* Argument BINARY_OP. */ + gcc_type, /* Argument OPERAND1. */ + gcc_expr) /* Argument OPERAND2. */ + +/* Build a gcc_expr that denotes the conversion of an expression list + VALUES to TYPE, with ("tl") or without ("cv") braces, or a braced + initializer list of unspecified type (e.g., a component of another + braced initializer list; pass "il" for CONV_OP, and NULL for + TYPE). */ + +GCC_METHOD3 (gcc_expr, build_expression_list_expr, + const char *, /* Argument CONV_OP. */ + gcc_type, /* Argument TYPE. */ + const struct gcc_cp_function_args *) /* Argument VALUES. */ + +/* Build a gcc_expr that denotes a new ("nw") or new[] ("na") + expression of TYPE, with or without a GLOBAL_NS qualifier (prefix + the NEW_OP with "gs"), with or without PLACEMENT, with or without + INITIALIZER. If it's not a placement new, PLACEMENT must be NULL + (rather than a zero-length placement arg list). If there's no + specified initializer, INITIALIZER must be NULL; a zero-length arg + list stands for a default initializer. */ + +GCC_METHOD4 (gcc_expr, build_new_expr, + const char *, /* Argument NEW_OP. */ + const struct gcc_cp_function_args *, /* Argument PLACEMENT. */ + gcc_type, /* Argument TYPE. */ + const struct gcc_cp_function_args *) /* Argument INITIALIZER. */ + +/* Return a call expression that calls CALLABLE with arguments ARGS. + CALLABLE may be a function, a callable object, a pointer to + function, an unresolved expression, an unresolved overload set, an + object expression combined with a member function overload set or a + pointer-to-member. If QUALIFIED_P, CALLABLE will be interpreted as + a qualified name, preventing virtual function dispatch. */ + +GCC_METHOD3 (gcc_expr, build_call_expr, + gcc_expr, /* Argument CALLABLE. */ + int /* bool */, /* Argument QUALIFIED_P. */ + const struct gcc_cp_function_args *) /* Argument ARGS. */ + +/* Return the type of the gcc_expr OPERAND. + Use this for decltype. + For decltype (auto), pass a NULL OPERAND. + + Note: for template-dependent expressions, the result is NULL, + because the type is only computed when template argument + substitution is performed. */ + +GCC_METHOD1 (gcc_type, get_expr_type, + gcc_expr) /* Argument OPERAND. */ + +/* Introduce a specialization of a template function. + + TEMPLATE_DECL is the template function, and TARGS are the arguments + for the specialization. ADDRESS is the address of the + specialization. FILENAME and LINE_NUMBER specify the source + location associated with the template function specialization. */ + +GCC_METHOD5 (gcc_decl, build_function_template_specialization, + gcc_decl, /* Argument TEMPLATE_DECL. */ + const struct gcc_cp_template_args *, /* Argument TARGS. */ + gcc_address, /* Argument ADDRESS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Specialize a template class as an incomplete type. A definition + can be supplied later, with start_class_type. + + TEMPLATE_DECL is the template class, and TARGS are the arguments + for the specialization. FILENAME and LINE_NUMBER specify the + source location associated with the template class + specialization. */ + +GCC_METHOD4 (gcc_decl, build_class_template_specialization, + gcc_decl, /* Argument TEMPLATE_DECL. */ + const struct gcc_cp_template_args *, /* Argument TARGS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Start defining a 'class', 'struct' or 'union' type, entering its + own binding level. Initially it has no fields. + + TYPEDECL is the forward-declaration of the type, returned by + build_decl. BASE_CLASSES indicate the base classes of class NAME. + FILENAME and LINE_NUMBER specify the source location associated + with the class definition, should they be different from those of + the forward declaration. */ + +GCC_METHOD4 (gcc_type, start_class_type, + gcc_decl, /* Argument TYPEDECL. */ + const struct gcc_vbase_array *,/* Argument BASE_CLASSES. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Create a new closure class type, record it as the + DISCRIMINATOR-numbered closure type in the current scope (or + associated with EXTRA_SCOPE, if non-NULL), and enter the closure + type's own binding level. This primitive would sort of combine + build_decl and start_class_type, if they could be used to introduce + a closure type. Initially it has no fields. + + FILENAME and LINE_NUMBER specify the source location associated + with the class. EXTRA_SCOPE, if non-NULL, must be a PARM_DECL of + the current function, or a FIELD_DECL of the current class. If it + is NULL, the current scope must be a function. */ + +GCC_METHOD5 (gcc_type, start_closure_class_type, + int, /* Argument DISCRIMINATOR. */ + gcc_decl, /* Argument EXTRA_SCOPE. */ + enum gcc_cp_symbol_kind, /* Argument FLAGS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Add a non-static data member to the most-recently-started + unfinished struct or union type. FIELD_NAME is the field's name. + FIELD_TYPE is the type of the field. BITSIZE and BITPOS indicate + where in the struct the field occurs. */ + +GCC_METHOD5 (gcc_decl, build_field, + const char *, /* Argument FIELD_NAME. */ + gcc_type, /* Argument FIELD_TYPE. */ + enum gcc_cp_symbol_kind, /* Argument FIELD_FLAGS. */ + unsigned long, /* Argument BITSIZE. */ + unsigned long) /* Argument BITPOS. */ + +/* After all the fields have been added to a struct, class or union, + the struct or union type must be "finished". This does some final + cleanups in GCC, and pops to the binding level that was in effect + before the matching start_class_type or + start_closure_class_type. */ + +GCC_METHOD1 (int /* bool */, finish_class_type, + unsigned long) /* Argument SIZE_IN_BYTES. */ + +/* Create a new 'enum' type, and record it in the current binding + level. The new type initially has no associated constants. + + NAME is the enum name. FILENAME and LINE_NUMBER specify its source + location. */ + +GCC_METHOD5 (gcc_type, start_enum_type, + const char *, /* Argument NAME. */ + gcc_type, /* Argument UNDERLYING_INT_TYPE. */ + enum gcc_cp_symbol_kind, /* Argument FLAGS. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Add a new constant to an enum type. NAME is the constant's name + and VALUE is its value. Returns a gcc_decl for the constant. */ + +GCC_METHOD3 (gcc_decl, build_enum_constant, + gcc_type, /* Argument ENUM_TYPE. */ + const char *, /* Argument NAME. */ + unsigned long) /* Argument VALUE. */ + +/* After all the constants have been added to an enum, the type must + be "finished". This does some final cleanups in GCC. */ + +GCC_METHOD1 (int /* bool */, finish_enum_type, + gcc_type) /* Argument ENUM_TYPE. */ + +/* Create a new function type. RETURN_TYPE is the type returned by + the function, and ARGUMENT_TYPES is a vector, of length NARGS, of + the argument types. IS_VARARGS is true if the function is + varargs. */ + +GCC_METHOD3 (gcc_type, build_function_type, + gcc_type, /* Argument RETURN_TYPE. */ + const struct gcc_type_array *,/* Argument ARGUMENT_TYPES. */ + int /* bool */) /* Argument IS_VARARGS. */ + +/* Create a variant of a function type with an exception + specification. FUNCTION_TYPE is a function or method type. + EXCEPT_TYPES is an array with the list of exception types. Zero as + the array length implies throw() AKA noexcept(true); NULL as the + pointer to gcc_type_array implies noexcept(false), which is almost + equivalent (but distinguishable by the compiler) to an unspecified + exception list. */ + +GCC_METHOD2 (gcc_type, build_exception_spec_variant, + gcc_type, /* Argument FUNCTION_TYPE. */ + const struct gcc_type_array *)/* Argument EXCEPT_TYPES. */ + +/* Create a new non-static member function type. FUNC_TYPE is the + method prototype, without the implicit THIS pointer, added as a + pointer to the QUALS-qualified CLASS_TYPE. If CLASS_TYPE is NULL, + this creates a cv-qualified (member) function type not associated + with any specific class, as needed to support "typedef void f(int) + const;", which can later be used to declare member functions and + pointers to member functions. */ + +GCC_METHOD4 (gcc_type, build_method_type, + gcc_type, /* Argument CLASS_TYPE. */ + gcc_type, /* Argument FUNC_TYPE. */ + enum gcc_cp_qualifiers, /* Argument QUALS. */ + enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ + +/* Return a declaration for the (INDEX - 1)th argument of + FUNCTION_DECL, i.e., for the first argument, use zero as the index. + If FUNCTION_DECL is a non-static member function, use -1 to get the + implicit THIS parameter. */ + +GCC_METHOD2 (gcc_decl, get_function_parameter_decl, + gcc_decl, /* Argument FUNCTION_DECL. */ + int) /* Argument INDEX. */ + +/* Return a lambda expr that constructs an instance of CLOSURE_TYPE. + Only lambda exprs without any captures can be correctly created + through these mechanisms; that's all we need to support lambdas + expressions in default parameters, the only kind that may have to + be introduced through this interface. */ + +GCC_METHOD1 (gcc_expr, build_lambda_expr, + gcc_type) /* Argument CLOSURE_TYPE. */ + +/* Return an integer type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD3 (gcc_type, get_int_type, + int /* bool */, /* Argument IS_UNSIGNED. */ + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + +/* Return the 'char' type, a distinct type from both 'signed char' and + 'unsigned char' returned by int_type. */ + +GCC_METHOD0 (gcc_type, get_char_type) + +/* Return a floating point type with the given properties. If BUILTIN_NAME + is non-NULL, it must name a builtin integral type with the given + signedness and size, and that is the type that will be returned. */ + +GCC_METHOD2 (gcc_type, get_float_type, + unsigned long, /* Argument SIZE_IN_BYTES. */ + const char *) /* Argument BUILTIN_NAME. */ + +/* Return the 'void' type. */ + +GCC_METHOD0 (gcc_type, get_void_type) + +/* Return the 'bool' type. */ + +GCC_METHOD0 (gcc_type, get_bool_type) + +/* Return the std::nullptr_t type. */ + +GCC_METHOD0 (gcc_type, get_nullptr_type) + +/* Return the nullptr constant. */ + +GCC_METHOD0 (gcc_expr, get_nullptr_constant) + +/* Create a new array type. If NUM_ELEMENTS is -1, then the array + is assumed to have an unknown length. */ + +GCC_METHOD2 (gcc_type, build_array_type, + gcc_type, /* Argument ELEMENT_TYPE. */ + int) /* Argument NUM_ELEMENTS. */ + +/* Create a new array type. NUM_ELEMENTS is a template-dependent + expression. */ + +GCC_METHOD2 (gcc_type, build_dependent_array_type, + gcc_type, /* Argument ELEMENT_TYPE. */ + gcc_expr) /* Argument NUM_ELEMENTS. */ + +/* Create a new variably-sized array type. UPPER_BOUND_NAME is the + name of a local variable that holds the upper bound of the array; + it is one less than the array size. */ + +GCC_METHOD2 (gcc_type, build_vla_array_type, + gcc_type, /* Argument ELEMENT_TYPE. */ + const char *) /* Argument UPPER_BOUND_NAME. */ + +/* Return a qualified variant of a given base type. QUALIFIERS says + which qualifiers to use; it is composed of or'd together + constants from 'enum gcc_cp_qualifiers'. */ + +GCC_METHOD2 (gcc_type, build_qualified_type, + gcc_type, /* Argument UNQUALIFIED_TYPE. */ + enum gcc_cp_qualifiers) /* Argument QUALIFIERS. */ + +/* Build a complex type given its element type. */ + +GCC_METHOD1 (gcc_type, build_complex_type, + gcc_type) /* Argument ELEMENT_TYPE. */ + +/* Build a vector type given its element type and number of + elements. */ + +GCC_METHOD2 (gcc_type, build_vector_type, + gcc_type, /* Argument ELEMENT_TYPE. */ + int) /* Argument NUM_ELEMENTS. */ + +/* Build a constant. NAME is the constant's name and VALUE is its + value. FILENAME and LINE_NUMBER refer to the type's source + location. If this is not known, FILENAME can be NULL and + LINE_NUMBER can be 0. */ + +GCC_METHOD5 (int /* bool */, build_constant, + gcc_type, /* Argument TYPE. */ + const char *, /* Argument NAME. */ + unsigned long, /* Argument VALUE. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +/* Emit an error and return an error type object. */ + +GCC_METHOD1 (gcc_type, error, + const char *) /* Argument MESSAGE. */ + +/* Declare a static_assert with the given CONDITION and ERRORMSG at + FILENAME:LINE_NUMBER. */ + +GCC_METHOD4 (int /* bool */, add_static_assert, + gcc_expr, /* Argument CONDITION. */ + const char *, /* Argument ERRORMSG. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ + +#if 0 + +/* FIXME: We don't want to expose the internal implementation detail + that default parms are stored in function types, and it's not clear + how this or other approaches would interact with the type sharing + of e.g. ctor clones, so we're leaving this out, since default args + are not even present in debug information anyway. Besides, the set + of default args for a function may grow within its scope, and vary + independently in other scopes. */ + +/* Create a modified version of a function type that has default + values for some of its arguments. The returned type should ONLY be + used to define functions or methods, never to declare parameters, + variables, types or the like. + + DEFAULTS must have at most as many N_ELEMENTS as there are + arguments without default values in FUNCTION_TYPE. Say, if + FUNCTION_TYPE has an argument list such as (T1, T2, T3, T4 = V0) + and DEFAULTS has 2 elements (V1, V2), the returned type will have + the following argument list: (T1, T2 = V1, T3 = V2, T4 = V0). + + Any NULL expressions in DEFAULTS will be marked as deferred, and + they should be filled in with set_deferred_function_default_args. */ + +GCC_METHOD2 (gcc_type, add_function_default_args, + gcc_type, /* Argument FUNCTION_TYPE. */ + const struct gcc_cp_function_args *) /* Argument DEFAULTS. */ + +/* Fill in the first deferred default args in FUNCTION_DECL with the + expressions given in DEFAULTS. This can be used when the + declaration of a parameter is needed to create a default + expression, such as taking the size of an earlier parameter, or + building a lambda expression in the parameter's context. */ + +GCC_METHOD2 (int /* bool */, set_deferred_function_default_args, + gcc_decl, /* Argument FUNCTION_DECL. */ + const struct gcc_cp_function_args *) /* Argument DEFAULTS. */ + +#endif + + +/* When you add entry points, add them at the end, so that the new API + version remains compatible with the old version. + + The following conventions have been observed as to naming entry points: + + - build_* creates (and maybe records) something and returns it; + - add_* creates and records something, but doesn't return it; + - get_* obtains something without creating it; + - start_* marks the beginning of a compound (type, list, ...); + - finish_* completes the compound when needed. + + Entry points that return an int (bool) and don't have a return value + specification return nonzero (true) on success and zero (false) on + failure. This is in line with libcc1's conventions of returning a + zero-initialized value in case of e.g. a transport error. */ diff --git a/include/gcc-cp-interface.h b/include/gcc-cp-interface.h new file mode 100644 index 0000000..6ef9e22 --- /dev/null +++ b/include/gcc-cp-interface.h @@ -0,0 +1,496 @@ +/* Interface between GCC C++ FE and GDB + + Copyright (C) 2014-2017 Free Software Foundation, Inc. + + This file is part of GCC. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef GCC_CP_INTERFACE_H +#define GCC_CP_INTERFACE_H + +#include "gcc-interface.h" + +/* This header defines the interface to the GCC API. It must be both + valid C and valid C++, because it is included by both programs. */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Forward declaration. */ + +struct gcc_cp_context; + +/* + * Definitions and declarations for the C++ front end. + */ + +/* Defined versions of the C++ front-end API. */ + +enum gcc_cp_api_version +{ + GCC_CP_FE_VERSION_0 = 0 +}; + +/* Qualifiers. */ + +enum gcc_cp_qualifiers +{ + GCC_CP_QUALIFIER_CONST = 1, + GCC_CP_QUALIFIER_VOLATILE = 2, + GCC_CP_QUALIFIER_RESTRICT = 4 +}; + +/* Ref qualifiers. */ + +enum gcc_cp_ref_qualifiers { + GCC_CP_REF_QUAL_NONE = 0, + GCC_CP_REF_QUAL_LVALUE = 1, + GCC_CP_REF_QUAL_RVALUE = 2 +}; + +/* Opaque typedef for unbound class templates. They are used for + template arguments, and defaults for template template + parameters. */ + +typedef unsigned long long gcc_utempl; + +/* Opaque typedef for expressions. They are used for template + arguments, defaults for non-type template parameters, and defaults + for function arguments. */ + +typedef unsigned long long gcc_expr; + +typedef enum + { GCC_CP_TPARG_VALUE, GCC_CP_TPARG_CLASS, + GCC_CP_TPARG_TEMPL, GCC_CP_TPARG_PACK } +gcc_cp_template_arg_kind; + +typedef union +{ gcc_expr value; gcc_type type; gcc_utempl templ; gcc_type pack; } +gcc_cp_template_arg; + +/* An array of template arguments. */ + +struct gcc_cp_template_args +{ + /* Number of elements. */ + + int n_elements; + + /* kind[i] indicates what kind of template argument type[i] is. */ + + char /* gcc_cp_template_arg_kind */ *kinds; + + /* The template arguments. */ + + gcc_cp_template_arg *elements; +}; + +/* An array of (default) function arguments. */ + +struct gcc_cp_function_args +{ + /* Number of elements. */ + + int n_elements; + + /* The (default) values for each argument. */ + + gcc_expr *elements; +}; + +/* This enumerates the kinds of decls that GDB can create. */ + +enum gcc_cp_symbol_kind +{ + /* A function. */ + + GCC_CP_SYMBOL_FUNCTION, + + /* A variable. */ + + GCC_CP_SYMBOL_VARIABLE, + + /* A typedef, or an alias declaration (including template ones). */ + + GCC_CP_SYMBOL_TYPEDEF, + + /* A label. */ + + GCC_CP_SYMBOL_LABEL, + + /* A class, forward declared in build_decl (to be later defined in + start_class_definition), or, in a template parameter list scope, + a declaration of a template class, closing the parameter + list. */ + + GCC_CP_SYMBOL_CLASS, + + /* A union, forward declared in build_decl (to be later defined in + start_class_definition). */ + + GCC_CP_SYMBOL_UNION, + + /* An enumeration type being introduced with start_new_enum_type. */ + + GCC_CP_SYMBOL_ENUM, + + /* A nonstatic data member being introduced with new_field. */ + + GCC_CP_SYMBOL_FIELD, + + /* A base class in a gcc_vbase_array. */ + + GCC_CP_SYMBOL_BASECLASS, + + /* A using declaration in new_using_decl. */ + + GCC_CP_SYMBOL_USING, + + /* A (lambda) closure class type. In many regards this is just like + a regular class, but it's not supposed to have base classes, some + of the member functions that are usually implicitly-defined are + deleted, and it should have an operator() member function that + holds the lambda body. We can't instantiate objects of lambda + types from the snippet, but we can interact with them in such + ways as passing them to functions that take their types, and + calling their body. */ + + GCC_CP_SYMBOL_LAMBDA_CLOSURE, + + /* Marker to check that we haven't exceeded GCC_CP_SYMBOL_MASK. */ + GCC_CP_SYMBOL_END, + + GCC_CP_SYMBOL_MASK = 15, + + /* When defining a class member, at least one of the + GCC_CP_ACCESS_MASK bits must be set; when defining a namespace- + or union-scoped symbol, none of them must be set. */ + + GCC_CP_ACCESS_PRIVATE, + GCC_CP_ACCESS_PUBLIC = GCC_CP_ACCESS_PRIVATE << 1, + GCC_CP_ACCESS_MASK = (GCC_CP_ACCESS_PUBLIC + | GCC_CP_ACCESS_PRIVATE), + GCC_CP_ACCESS_PROTECTED = GCC_CP_ACCESS_MASK, + GCC_CP_ACCESS_NONE = 0, + + GCC_CP_FLAG_BASE = GCC_CP_ACCESS_PRIVATE << 2, + + /* Flags to be used along with GCC_CP_SYMBOL_FUNCTION: */ + + /* This flag should be set for constructors, destructors and + operators. */ + GCC_CP_FLAG_SPECIAL_FUNCTION = GCC_CP_FLAG_BASE, + + /* We intentionally cannot express inline, constexpr, or virtual + override for functions. We can't inline or constexpr-replace + without a source-level body. The override keyword is only + meaningful within the definition of the containing class. */ + + /* This indicates a "virtual" member function, explicitly or + implicitly (due to a virtual function with the same name and + prototype in a base class) declared as such. */ + GCC_CP_FLAG_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 1, + + /* The following two flags should only be set when the flag above is + set. */ + + /* This indicates a pure virtual member function, i.e., one that is + declared with "= 0", even if a body is provided in the + definition. */ + GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 2, + + /* This indicates a "final" virtual member function. */ + GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 3, + + /* This indicates a special member function should have its default + implementation. This either means the function declaration + contains the "= default" tokens, or that the member function was + implicitly generated by the compiler, although the latter use is + discouraged: just let the compiler implicitly introduce it. + + A member function defaulted after its first declaration has + slightly different ABI implications from one implicitly generated + or explicitly defaulted at the declaration (and definition) + point. To avoid silent (possibly harmless) violation of the one + definition rule, it is recommended that this flag not be used for + such functions, and that the address of the definition be + supplied instead. */ + GCC_CP_FLAG_DEFAULTED_FUNCTION = GCC_CP_FLAG_BASE << 4, + + /* This indicates a deleted member function, i.e., one that has been + defined as "= delete" at its declaration point, or one that has + been implicitly defined as deleted (with or without an explicit + "= default" definition). + + This should not be used for implicitly-declared member functions + that resolve to deleted definitions, as it may affect the + implicit declaration of other member functions. */ + GCC_CP_FLAG_DELETED_FUNCTION = GCC_CP_FLAG_BASE << 5, + + /* This indicates a constructor or type-conversion operator declared + as "explicit". */ + + GCC_CP_FLAG_EXPLICIT_FUNCTION = GCC_CP_FLAG_BASE << 6, + + GCC_CP_FLAG_END_FUNCTION, + GCC_CP_FLAG_MASK_FUNCTION = (((GCC_CP_FLAG_END_FUNCTION - 1) << 1) + - GCC_CP_FLAG_BASE), + + /* Flags to be used along with GCC_CP_SYMBOL_VARIABLE: */ + + /* This indicates a variable declared as "constexpr". */ + + GCC_CP_FLAG_CONSTEXPR_VARIABLE = GCC_CP_FLAG_BASE, + + /* This indicates a variable declared as "thread_local". ??? What + should the ADDRESS be? */ + + GCC_CP_FLAG_THREAD_LOCAL_VARIABLE = GCC_CP_FLAG_BASE << 1, + + GCC_CP_FLAG_END_VARIABLE, + GCC_CP_FLAG_MASK_VARIABLE = (((GCC_CP_FLAG_END_VARIABLE - 1) << 1) + - GCC_CP_FLAG_BASE), + + /* Flags to be used when defining nonstatic data members of classes + with new_field. */ + + /* Use this when no flags are present. */ + GCC_CP_FLAG_FIELD_NOFLAG = 0, + + /* This indicates the field is declared as mutable. */ + GCC_CP_FLAG_FIELD_MUTABLE = GCC_CP_FLAG_BASE, + + GCC_CP_FLAG_END_FIELD, + GCC_CP_FLAG_MASK_FIELD = (((GCC_CP_FLAG_END_FIELD - 1) << 1) + - GCC_CP_FLAG_BASE), + + /* Flags to be used when defining an enum with + start_new_enum_type. */ + + /* This indicates an enum type without any flags. */ + GCC_CP_FLAG_ENUM_NOFLAG = 0, + + /* This indicates a scoped enum type. */ + GCC_CP_FLAG_ENUM_SCOPED = GCC_CP_FLAG_BASE, + + GCC_CP_FLAG_END_ENUM, + GCC_CP_FLAG_MASK_ENUM = (((GCC_CP_FLAG_END_ENUM - 1) << 1) + - GCC_CP_FLAG_BASE), + + + /* Flags to be used when introducing a class or a class template + with build_decl. */ + + /* This indicates an enum type without any flags. */ + GCC_CP_FLAG_CLASS_NOFLAG = 0, + + /* This indicates the class is actually a struct. This has no + effect whatsoever on access control in this interface, since all + class members must have explicit access control bits set, but it + may affect error messages. */ + GCC_CP_FLAG_CLASS_IS_STRUCT = GCC_CP_FLAG_BASE, + + GCC_CP_FLAG_END_CLASS, + GCC_CP_FLAG_MASK_CLASS = (((GCC_CP_FLAG_END_CLASS - 1) << 1) + - GCC_CP_FLAG_BASE), + + + /* Flags to be used when introducing a virtual base class in a + gcc_vbase_array. */ + + /* This indicates an enum type without any flags. */ + GCC_CP_FLAG_BASECLASS_NOFLAG = 0, + + /* This indicates the class is actually a struct. This has no + effect whatsoever on access control in this interface, since all + class members must have explicit access control bits set, but it + may affect error messages. */ + GCC_CP_FLAG_BASECLASS_VIRTUAL = GCC_CP_FLAG_BASE, + + GCC_CP_FLAG_END_BASECLASS, + GCC_CP_FLAG_MASK_BASECLASS = (((GCC_CP_FLAG_END_BASECLASS - 1) << 1) + - GCC_CP_FLAG_BASE), + + + GCC_CP_FLAG_MASK = (GCC_CP_FLAG_MASK_FUNCTION + | GCC_CP_FLAG_MASK_VARIABLE + | GCC_CP_FLAG_MASK_FIELD + | GCC_CP_FLAG_MASK_ENUM + | GCC_CP_FLAG_MASK_CLASS + | GCC_CP_FLAG_MASK_BASECLASS + ) +}; + + +/* An array of types used for creating lists of base classes. */ + +struct gcc_vbase_array +{ + /* Number of elements. */ + + int n_elements; + + /* The base classes. */ + + gcc_type *elements; + + /* Flags for each base class. Used to indicate access control and + virtualness. */ + + enum gcc_cp_symbol_kind *flags; +}; + + +/* This enumerates the types of symbols that GCC might request from + GDB. */ + +enum gcc_cp_oracle_request +{ + /* An identifier in namespace scope -- type, variable, function, + namespace, template. All namespace-scoped symbols with the + requested name, in any namespace (including the global + namespace), should be defined in response to this request. */ + + GCC_CP_ORACLE_IDENTIFIER +}; + +/* The type of the function called by GCC to ask GDB for a symbol's + definition. DATUM is an arbitrary value supplied when the oracle + function is registered. CONTEXT is the GCC context in which the + request is being made. REQUEST specifies what sort of symbol is + being requested, and IDENTIFIER is the name of the symbol. */ + +typedef void gcc_cp_oracle_function (void *datum, + struct gcc_cp_context *context, + enum gcc_cp_oracle_request request, + const char *identifier); + +/* The type of the function called by GCC to ask GDB for a symbol's + address. This should return 0 if the address is not known. */ + +typedef gcc_address gcc_cp_symbol_address_function (void *datum, + struct gcc_cp_context *ctxt, + const char *identifier); + +/* The type of the function called by GCC to ask GDB to enter or leave + the user expression scope. */ + +typedef void gcc_cp_enter_leave_user_expr_scope_function (void *datum, + struct gcc_cp_context + *context); + +/* The vtable used by the C front end. */ + +struct gcc_cp_fe_vtable +{ + /* The version of the C interface. The value is one of the + gcc_cp_api_version constants. */ + + unsigned int cp_version; + + /* Set the callbacks for this context. + + The binding oracle is called whenever the C++ parser needs to + look up a symbol. This gives the caller a chance to lazily + instantiate symbols using other parts of the gcc_cp_fe_interface + API. The symbol is looked up without a scope, and the oracle + must supply a definition for ALL namespace-scoped definitions + bound to the symbol. + + The address oracle is called whenever the C++ parser needs to + look up a symbol. This may be called for symbols not provided by + the symbol oracle, such as built-in functions where GCC provides + the declaration; other internal symbols, such as those related + with thunks, rtti, and virtual tables are likely to be queried + through this interface too. The identifier is a mangled symbol + name. + + DATUM is an arbitrary piece of data that is passed back verbatim + to the callbacks in requests. */ + + void (*set_callbacks) (struct gcc_cp_context *self, + gcc_cp_oracle_function *binding_oracle, + gcc_cp_symbol_address_function *address_oracle, + gcc_cp_enter_leave_user_expr_scope_function *enter_scope, + gcc_cp_enter_leave_user_expr_scope_function *leave_scope, + void *datum); + +#define GCC_METHOD0(R, N) \ + R (*N) (struct gcc_cp_context *); +#define GCC_METHOD1(R, N, A) \ + R (*N) (struct gcc_cp_context *, A); +#define GCC_METHOD2(R, N, A, B) \ + R (*N) (struct gcc_cp_context *, A, B); +#define GCC_METHOD3(R, N, A, B, C) \ + R (*N) (struct gcc_cp_context *, A, B, C); +#define GCC_METHOD4(R, N, A, B, C, D) \ + R (*N) (struct gcc_cp_context *, A, B, C, D); +#define GCC_METHOD5(R, N, A, B, C, D, E) \ + R (*N) (struct gcc_cp_context *, A, B, C, D, E); +#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ + R (*N) (struct gcc_cp_context *, A, B, C, D, E, F, G); + +#include "gcc-cp-fe.def" + +#undef GCC_METHOD0 +#undef GCC_METHOD1 +#undef GCC_METHOD2 +#undef GCC_METHOD3 +#undef GCC_METHOD4 +#undef GCC_METHOD5 +#undef GCC_METHOD7 + +}; + +/* The C front end object. */ + +struct gcc_cp_context +{ + /* Base class. */ + + struct gcc_base_context base; + + /* Our vtable. This is a separate field because this is simpler + than implementing a vtable inheritance scheme in C. */ + + const struct gcc_cp_fe_vtable *cp_ops; +}; + +/* The name of the .so that the compiler builds. We dlopen this + later. */ + +#define GCC_CP_FE_LIBCC libcc1.so + +/* The compiler exports a single initialization function. This macro + holds its name as a symbol. */ + +#define GCC_CP_FE_CONTEXT gcc_cp_fe_context + +/* The type of the initialization function. The caller passes in the + desired base version and desired C-specific version. If the + request can be satisfied, a compatible gcc_context object will be + returned. Otherwise, the function returns NULL. */ + +typedef struct gcc_cp_context *gcc_cp_fe_context_function + (enum gcc_base_api_version, + enum gcc_cp_api_version); + +#ifdef __cplusplus +} +#endif + +#endif /* GCC_CP_INTERFACE_H */ diff --git a/include/gcc-interface.h b/include/gcc-interface.h index d4c4ec6..1dc3498 100644 --- a/include/gcc-interface.h +++ b/include/gcc-interface.h @@ -44,7 +44,12 @@ struct gcc_base_context; enum gcc_base_api_version { - GCC_FE_VERSION_0 = 0 + GCC_FE_VERSION_0 = 0, + + /* Deprecated methods set_arguments_v0 and compile_v0. Added methods + set_arguments, set_triplet_regexp, set_driver_filename, set_verbose and + compile. */ + GCC_FE_VERSION_1 = 1, }; /* The operations defined by the GCC base API. This is the vtable for @@ -64,20 +69,12 @@ struct gcc_base_vtable unsigned int version; - /* Set the compiler's command-line options for the next compilation. - TRIPLET_REGEXP is a regular expression that is used to match the - configury triplet prefix to the compiler. - The arguments are copied by GCC. ARGV need not be - NULL-terminated. The arguments must be set separately for each - compilation; that is, after a compile is requested, the - previously-set arguments cannot be reused. + /* Deprecated GCC_FE_VERSION_0 variant of the GCC_FE_VERSION_1 + methods set_triplet_regexp and set_arguments. */ - This returns NULL on success. On failure, returns a malloc()d - error message. The caller is responsible for freeing it. */ - - char *(*set_arguments) (struct gcc_base_context *self, - const char *triplet_regexp, - int argc, char **argv); + char *(*set_arguments_v0) (struct gcc_base_context *self, + const char *triplet_regexp, + int argc, char **argv); /* Set the file name of the program to compile. The string is copied by the method implementation, but the caller must @@ -93,18 +90,74 @@ struct gcc_base_vtable const char *message), void *datum); - /* Perform the compilation. FILENAME is the name of the resulting - object file. VERBOSE can be set to cause GCC to print some - information as it works. Returns true on success, false on - error. */ + /* Deprecated GCC_FE_VERSION_0 variant of the GCC_FE_VERSION_1 + compile method. GCC_FE_VERSION_0 version verbose parameter has + been replaced by the set_verbose method. */ - int /* bool */ (*compile) (struct gcc_base_context *self, - const char *filename, - int /* bool */ verbose); + int /* bool */ (*compile_v0) (struct gcc_base_context *self, + const char *filename, + int /* bool */ verbose); /* Destroy this object. */ void (*destroy) (struct gcc_base_context *self); + + /* VERBOSE can be set to non-zero to cause GCC to print some + information as it works. Calling this method overrides its + possible previous calls. + + This method is only available since GCC_FE_VERSION_1. */ + + void (*set_verbose) (struct gcc_base_context *self, + int /* bool */ verbose); + + /* Perform the compilation. FILENAME is the name of the resulting + object file. Either set_triplet_regexp or set_driver_filename must + be called before. Returns true on success, false on error. + + This method is only available since GCC_FE_VERSION_1. */ + + int /* bool */ (*compile) (struct gcc_base_context *self, + const char *filename); + + /* Set the compiler's command-line options for the next compilation. + The arguments are copied by GCC. ARGV need not be + NULL-terminated. The arguments must be set separately for each + compilation; that is, after a compile is requested, the + previously-set arguments cannot be reused. + + This returns NULL on success. On failure, returns a malloc()d + error message. The caller is responsible for freeing it. + + This method is only available since GCC_FE_VERSION_1. */ + + char *(*set_arguments) (struct gcc_base_context *self, + int argc, char **argv); + + /* Set TRIPLET_REGEXP as a regular expression that is used to match + the configury triplet prefix to the compiler. Calling this method + overrides possible previous call of itself or set_driver_filename. + + This returns NULL on success. On failure, returns a malloc()d + error message. The caller is responsible for freeing it. + + This method is only available since GCC_FE_VERSION_1. */ + + char *(*set_triplet_regexp) (struct gcc_base_context *self, + const char *triplet_regexp); + + /* DRIVER_FILENAME should be filename of the gcc compiler driver + program. It will be searched in PATH components like + TRIPLET_REGEXP. Calling this method overrides possible previous + call of itself or set_triplet_regexp. + + This returns NULL on success. On failure, returns a malloc()d + error message. The caller is responsible for freeing it. + + This method is only available since GCC_FE_VERSION_1. */ + + char *(*set_driver_filename) (struct gcc_base_context *self, + const char *driver_filename); }; /* The GCC object. */ @@ -116,6 +169,20 @@ struct gcc_base_context const struct gcc_base_vtable *ops; }; +/* An array of types used for creating function types in multiple + languages. */ + +struct gcc_type_array +{ + /* Number of elements. */ + + int n_elements; + + /* The elements. */ + + gcc_type *elements; +}; + /* The name of the dummy wrapper function generated by gdb. */ #define GCC_FE_WRAPPER_FUNCTION "_gdb_expr" diff --git a/include/gdb/remote-sim.h b/include/gdb/remote-sim.h index 9b8d3dc..9af0310 100644 --- a/include/gdb/remote-sim.h +++ b/include/gdb/remote-sim.h @@ -261,7 +261,7 @@ int sim_stop (SIM_DESC sd); that information is not directly accessable via this interface. SIM_SIGNALLED: The program has been terminated by a signal. The - simulator has encountered target code that causes the the program + simulator has encountered target code that causes the program to exit with signal SIGRC. SIM_RUNNING, SIM_POLLING: The return of one of these values diff --git a/include/libiberty.h b/include/libiberty.h index 7a79612..a0cbbcf 100644 --- a/include/libiberty.h +++ b/include/libiberty.h @@ -724,7 +724,7 @@ extern void *C_alloca (size_t) ATTRIBUTE_MALLOC; # define ASTRDUP(X) \ (__extension__ ({ const char *const libiberty_optr = (X); \ const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \ - char *const libiberty_nptr = (char *const) alloca (libiberty_len); \ + char *const libiberty_nptr = (char *) alloca (libiberty_len); \ (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); })) #else # define alloca(x) C_alloca(x) diff --git a/include/longlong.h b/include/longlong.h index 0ec11c5..c24568a 100644 --- a/include/longlong.h +++ b/include/longlong.h @@ -197,17 +197,17 @@ extern UDItype __udiv_qrnnd (UDItype *, UDItype, UDItype, UDItype); : "=r" ((USItype) (sh)), \ "=&r" ((USItype) (sl)) \ : "%r" ((USItype) (ah)), \ - "rIJ" ((USItype) (bh)), \ + "rICal" ((USItype) (bh)), \ "%r" ((USItype) (al)), \ - "rIJ" ((USItype) (bl))) + "rICal" ((USItype) (bl))) #define sub_ddmmss(sh, sl, ah, al, bh, bl) \ __asm__ ("sub.f %1, %4, %5\n\tsbc %0, %2, %3" \ : "=r" ((USItype) (sh)), \ "=&r" ((USItype) (sl)) \ : "r" ((USItype) (ah)), \ - "rIJ" ((USItype) (bh)), \ + "rICal" ((USItype) (bh)), \ "r" ((USItype) (al)), \ - "rIJ" ((USItype) (bl))) + "rICal" ((USItype) (bl))) #define __umulsidi3(u,v) ((UDItype)(USItype)u*(USItype)v) #ifdef __ARC_NORM__ @@ -221,8 +221,8 @@ extern UDItype __udiv_qrnnd (UDItype *, UDItype, UDItype, UDItype); } \ while (0) #define COUNT_LEADING_ZEROS_0 32 -#endif -#endif +#endif /* __ARC_NORM__ */ +#endif /* __arc__ */ #if defined (__arm__) && (defined (__thumb2__) || !defined (__thumb__)) \ && W_TYPE_SIZE == 32 @@ -858,42 +858,6 @@ extern UDItype __umulsidi3 (USItype, USItype); #endif #endif /* __mips__ */ -#if defined (__ns32000__) && W_TYPE_SIZE == 32 -#define umul_ppmm(w1, w0, u, v) \ - ({union {UDItype __ll; \ - struct {USItype __l, __h;} __i; \ - } __xx; \ - __asm__ ("meid %2,%0" \ - : "=g" (__xx.__ll) \ - : "%0" ((USItype) (u)), \ - "g" ((USItype) (v))); \ - (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;}) -#define __umulsidi3(u, v) \ - ({UDItype __w; \ - __asm__ ("meid %2,%0" \ - : "=g" (__w) \ - : "%0" ((USItype) (u)), \ - "g" ((USItype) (v))); \ - __w; }) -#define udiv_qrnnd(q, r, n1, n0, d) \ - ({union {UDItype __ll; \ - struct {USItype __l, __h;} __i; \ - } __xx; \ - __xx.__i.__h = (n1); __xx.__i.__l = (n0); \ - __asm__ ("deid %2,%0" \ - : "=g" (__xx.__ll) \ - : "0" (__xx.__ll), \ - "g" ((USItype) (d))); \ - (r) = __xx.__i.__l; (q) = __xx.__i.__h; }) -#define count_trailing_zeros(count,x) \ - do { \ - __asm__ ("ffsd %2,%0" \ - : "=r" ((USItype) (count)) \ - : "0" ((USItype) 0), \ - "r" ((USItype) (x))); \ - } while (0) -#endif /* __ns32000__ */ - /* FIXME: We should test _IBMR2 here when we add assembly support for the system vendor compilers. FIXME: What's needed for gcc PowerPC VxWorks? __vxworks__ is not good @@ -1086,7 +1050,7 @@ extern UDItype __umulsidi3 (USItype, USItype); } while (0) #endif -#if defined(__sh__) && (!defined (__SHMEDIA__) || !__SHMEDIA__) && W_TYPE_SIZE == 32 +#if defined(__sh__) && W_TYPE_SIZE == 32 #ifndef __sh1__ #define umul_ppmm(w1, w0, u, v) \ __asm__ ( \ @@ -1159,21 +1123,6 @@ extern UDItype __umulsidi3 (USItype, USItype); #endif /* __sh__ */ -#if defined (__SH5__) && defined (__SHMEDIA__) && __SHMEDIA__ && W_TYPE_SIZE == 32 -#define __umulsidi3(u,v) ((UDItype)(USItype)u*(USItype)v) -#define count_leading_zeros(count, x) \ - do \ - { \ - UDItype x_ = (USItype)(x); \ - SItype c_; \ - \ - __asm__ ("nsb %1, %0" : "=r" (c_) : "r" (x_)); \ - (count) = c_ - 31; \ - } \ - while (0) -#define COUNT_LEADING_ZEROS_0 32 -#endif - #if defined (__sparc__) && !defined (__arch64__) && !defined (__sparcv9) \ && W_TYPE_SIZE == 32 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \ diff --git a/include/mach-o/arm.h b/include/mach-o/arm.h index a2f2962..fd118a8 100644 --- a/include/mach-o/arm.h +++ b/include/mach-o/arm.h @@ -24,7 +24,7 @@ /* ARM relocations. */ #define BFD_MACH_O_ARM_RELOC_VANILLA 0 /* Generic relocation. */ #define BFD_MACH_O_ARM_RELOC_PAIR 1 /* Second entry in a pair. */ -#define BFD_MACH_O_ARM_RELOC_SECTDIFF 2 /* Substract with a PAIR. */ +#define BFD_MACH_O_ARM_RELOC_SECTDIFF 2 /* Subtract with a PAIR. */ #define BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF 3 /* Like above, but local ref. */ #define BFD_MACH_O_ARM_RELOC_PB_LA_PTR 4 /* Prebound lazy pointer. */ #define BFD_MACH_O_ARM_RELOC_BR24 5 /* 24bit branch. */ diff --git a/include/opcode/arc-func.h b/include/opcode/arc-func.h index c794593..fb45b07 100644 --- a/include/opcode/arc-func.h +++ b/include/opcode/arc-func.h @@ -274,8 +274,21 @@ replace_disp12s (unsigned insn, int value ATTRIBUTE_UNUSED) insn = insn & ~0xfff; insn |= ((value >> 0) & 0x003f) << 6; insn |= ((value >> 6) & 0x003f) << 0; - return insn; } #endif /* REPLACE_disp12s */ + +/* mask = 0000001111111111. */ +#ifndef REPLACE_jli +#define REPLACE_jli +ATTRIBUTE_UNUSED static unsigned +replace_jli (unsigned insn, int value) +{ + insn = insn & ~0x3ff; + insn |= ((value >> 0) & 0x03ff) << 0; + + return insn; +} + +#endif /* REPLACE_jli */ diff --git a/include/opcode/arc.h b/include/opcode/arc.h index 69b2630..cd8b1a8 100644 --- a/include/opcode/arc.h +++ b/include/opcode/arc.h @@ -76,6 +76,7 @@ typedef enum PMU, POP, PUSH, + SJLI, STORE, SUB, ULTRAIP, diff --git a/include/opcode/nds32.h b/include/opcode/nds32.h index 95e5f8c..5803834 100644 --- a/include/opcode/nds32.h +++ b/include/opcode/nds32.h @@ -50,8 +50,8 @@ static const int nds32_r54map[] ATTRIBUTE_UNUSED = -1, -1, -1, -1, -1, -1, -1, -1 }; -#define __BIT(n) (1 << (n)) -#define __MASK(n) (__BIT (n) - 1) +#define N32_BIT(n) (1 << (n)) +#define __MASK(n) (N32_BIT (n) - 1) #define __MF(v, off, bs) (((v) & __MASK (bs)) << (off)) #define __GF(v, off, bs) (((v) >> off) & __MASK (bs)) #define __SEXT(v, bs) ((((v) & ((1 << (bs)) - 1)) ^ (1 << ((bs) - 1))) - (1 << ((bs) - 1))) diff --git a/include/opcode/ppc.h b/include/opcode/ppc.h index cec0e10..a8274e1 100644 --- a/include/opcode/ppc.h +++ b/include/opcode/ppc.h @@ -70,6 +70,8 @@ extern const struct powerpc_opcode powerpc_opcodes[]; extern const int powerpc_num_opcodes; extern const struct powerpc_opcode vle_opcodes[]; extern const int vle_num_opcodes; +extern const struct powerpc_opcode spe2_opcodes[]; +extern const int spe2_num_opcodes; /* Values defined for the flags field of a struct powerpc_opcode. */ @@ -215,6 +217,15 @@ extern const int vle_num_opcodes; the underlying machine instruction. */ #define PPC_OPCODE_RAW 0x40000000000ull +/* Opcode is supported by PowerPC LSP */ +#define PPC_OPCODE_LSP 0x80000000000ull + +/* Opcode is only supported by Freescale SPE2 APU. */ +#define PPC_OPCODE_SPE2 0x100000000000ull + +/* Opcode is supported by EFS2. */ +#define PPC_OPCODE_EFS2 0x200000000000ull + /* A macro to extract the major opcode from an instruction. */ #define PPC_OP(i) (((i) >> 26) & 0x3f) @@ -226,6 +237,12 @@ extern const int vle_num_opcodes; /* A macro to convert a VLE opcode to a VLE opcode segment. */ #define VLE_OP_TO_SEG(i) ((i) >> 1) + +/* A macro to extract the extended opcode from a SPE2 instruction. */ +#define SPE2_XOP(i) ((i) & 0x7ff) + +/* A macro to convert a SPE2 extended opcode to a SPE2 xopcode segment. */ +#define SPE2_XOP_TO_SEG(i) ((i) >> 7) /* The operands table is an array of struct powerpc_operand. */ diff --git a/include/opcode/v850.h b/include/opcode/v850.h index b20ef10..31f96d8 100644 --- a/include/opcode/v850.h +++ b/include/opcode/v850.h @@ -230,10 +230,10 @@ extern const struct v850_operand v850_operands[]; /* The operand has '%' prefix. */ #define V850_OPERAND_PERCENT 0x200000 -/* This operand is a cache oparation. */ +/* This operand is a cache operation. */ #define V850_OPERAND_CACHEOP 0x400000 -/* This operand is a prefetch oparation. */ +/* This operand is a prefetch operation. */ #define V850_OPERAND_PREFOP 0x800000 /* A PC-relative displacement where a positive value indicates a backwards displacement. */ diff --git a/include/simple-object.h b/include/simple-object.h index 8a8439b..f1bf88b 100644 --- a/include/simple-object.h +++ b/include/simple-object.h @@ -197,6 +197,14 @@ simple_object_write_to_file (simple_object_write *simple_object, extern void simple_object_release_write (simple_object_write *); +/* Copy LTO debug sections from SRC_OBJECT to DEST. + If an error occurs, return the errno value in ERR and an error string. */ + +extern const char * +simple_object_copy_lto_debug_sections (simple_object_read *src_object, + const char *dest, + int *err); + #ifdef __cplusplus } #endif |