sdcc/support/cpp/gcc/cc1_dummies.cc

   1 // dummies for function used in cc1
   2
   3 #define SDCPP_DUMMY_FCT() fprintf(stderr, "unreachable dummy in cc1%s\n", __func__); gcc_assert(false)
   4 #define untested() fprintf(stderr, "untested in cc1: %s\n", __func__)
   5 #define CC1_DUMMIES
   6
   7 #include "config.h"
   8 #include "system.h"
   9 #include "coretypes.h"
  10 #include "bitmap.h"
  11
  12 #include "tree-core.h"
  13 #include "langhooks.h"
  14 #include "langhooks-def.h"
  15
  16 #include "incpath.h"
  17 #include "c/c-parser.h"
  18 #include "substring-locations.h"
  19 #include "pass_manager.h"
  20
  21 void bitmap_obstack_initialize(bitmap_obstack*)
  22 {
  23 }
  24 void bitmap_obstack_free(bitmap_head*)
  25 { SDCPP_DUMMY_FCT();
  26 }
  27 void bitmap_obstack_release(bitmap_obstack*)
  28 { SDCPP_DUMMY_FCT();
  29 }
  30 bitmap bitmap_alloc(bitmap_obstack*)
  31 {
  32   static bitmap bogus_bitmap;
  33   return bogus_bitmap;
  34 }
  35 void init_eh(void)
  36 {
  37 }
  38 tree build_tree_list(tree_node*, tree_node*)
  39 { SDCPP_DUMMY_FCT();
  40         return tree();
  41 }
  42 bool c_block_may_fallthru(tree_node const*)
  43 { SDCPP_DUMMY_FCT();
  44         return 0;
  45 }
  46 void c_common_read_pch(cpp_reader*, char const*, int, char const*)
  47 { SDCPP_DUMMY_FCT();
  48 }
  49 int c_common_valid_pch(cpp_reader*, char const*, int)
  50 { SDCPP_DUMMY_FCT();
  51         return 0;
  52 }
  53 bool c_dump_tree(void*, tree_node*)
  54 { SDCPP_DUMMY_FCT();
  55         return 0;
  56 }
  57 int c_get_alias_set(tree_node*)
  58 { SDCPP_DUMMY_FCT();
  59         return 0;
  60 }
  61 void c_initialize_diagnostics(diagnostic_context*)
  62 {
  63 }
  64 int c_gimplify_expr(tree_node**, gimple**, gimple**)
  65 { SDCPP_DUMMY_FCT();
  66         return 0;
  67 }
  68 bool c_missing_noreturn_ok_p(tree_node*)
  69 { SDCPP_DUMMY_FCT();
  70         return 0;
  71 }
  72 void c_parse_file()
  73 { SDCPP_DUMMY_FCT();
  74 }
  75 void c_parse_final_cleanups()
  76 { SDCPP_DUMMY_FCT();
  77 }
  78 void c_print_identifier(FILE*, tree_node*, int)
  79 { SDCPP_DUMMY_FCT();
  80 }
  81 void c_stddef_cpp_builtins()
  82 { SDCPP_DUMMY_FCT();
  83 }
  84 int c_types_compatible_p(tree_node*, tree_node*)
  85 { SDCPP_DUMMY_FCT();
  86         return 0;
  87 }
  88 void default_options_optimization(gcc_options*, gcc_options*, cl_decoded_option*, unsigned int, unsigned int, unsigned int, cl_option_handlers const*, diagnostic_context*)
  89 {
  90 }
  91 void define_language_independent_builtin_macros(cpp_reader*)
  92 { untested();
  93 }
  94 void dump_end(int, FILE*)
  95 { SDCPP_DUMMY_FCT();
  96 }
  97 void dbg_cnt_list_all_counters()
  98 { SDCPP_DUMMY_FCT();
  99 }
 100 FILE* dump_begin(int, dump_flag*, int)
 101 { SDCPP_DUMMY_FCT();
 102         return NULL;
 103 }
 104 void dump_profile_report()
 105 { SDCPP_DUMMY_FCT();
 106 }
 107 const struct gcc_debug_hooks *
 108 dump_go_spec_init(char const*, const struct gcc_debug_hooks*)
 109 { SDCPP_DUMMY_FCT();
 110 }
 111 bool dwarf2out_default_as_loc_support()
 112 {
 113         return false;
 114 }
 115 bool dwarf2out_default_as_locview_support()
 116 {
 117         return false;
 118 }
 119 void dwarf2out_do_cfi_asm()
 120 { SDCPP_DUMMY_FCT();
 121 }
 122 void emergency_dump_function()
 123 { untested();
 124 }
 125 void finalize_plugins()
 126 {
 127 }
 128 void gcc::dump_manager::register_dumps()
 129 {
 130 }
 131 tree get_identifier(char const*)
 132 { SDCPP_DUMMY_FCT();
 133         return 0;
 134 }
 135 int ggc_mark_stringpool()
 136 { SDCPP_DUMMY_FCT();
 137         return 0;
 138 }
 139 int ggc_purge_stringpool()
 140 { SDCPP_DUMMY_FCT();
 141         return 0;
 142 }
 143 void gt_clear_caches()
 144 { SDCPP_DUMMY_FCT();
 145 }
 146 void gt_ggc_m_S(void const*)
 147 { SDCPP_DUMMY_FCT();
 148 }
 149 void gt_pch_note_reorder (void*, void*, gt_handle_reorder)
 150 { SDCPP_DUMMY_FCT();
 151 }
 152 void gt_pch_p_S(void*, void*, void (*)(void*, void*, void*), void*)
 153 { SDCPP_DUMMY_FCT();
 154 }
 155 int gt_pch_restore_stringpool()
 156 { SDCPP_DUMMY_FCT();
 157         return 0;
 158 }
 159 int gt_pch_save_stringpool()
 160 { SDCPP_DUMMY_FCT();
 161         return 0;
 162 }
 163 int hook_int_const_tree_int(tree_node const*, int)
 164 { SDCPP_DUMMY_FCT();
 165         return 0;
 166 }
 167 void init_stringpool()
 168 {
 169 }
 170 void initialize_plugins()
 171 {
 172 }
 173 bool lang_GNU_C()
 174 {
 175         return true;
 176 }
 177 void lhd_append_data(void const*, size_t, void*)
 178 { SDCPP_DUMMY_FCT();
 179 }
 180 void lhd_begin_section(char const*)
 181 { SDCPP_DUMMY_FCT();
 182 }
 183 bool lhd_decl_ok_for_sibcall(tree_node const*)
 184 { SDCPP_DUMMY_FCT();
 185         return 0;
 186 }
 187 const char* lhd_decl_printable_name(tree_node*, int)
 188 { SDCPP_DUMMY_FCT();
 189         return 0;
 190 }
 191 void lhd_do_nothing()
 192 { untested();
 193 }
 194 void lhd_do_nothing_t(tree_node*)
 195 { SDCPP_DUMMY_FCT();
 196 }
 197 const char* lhd_dwarf_name(tree_node*, int)
 198 { SDCPP_DUMMY_FCT();
 199         return 0;
 200 }
 201 void lhd_end_section()
 202 { SDCPP_DUMMY_FCT();
 203 }
 204 const char* lhd_get_substring_location(substring_loc const&, unsigned int*)
 205 { SDCPP_DUMMY_FCT();
 206         return 0;
 207 }
 208 void lhd_overwrite_decl_assembler_name(tree_node*, tree_node*)
 209 { SDCPP_DUMMY_FCT();
 210 }
 211 void lhd_print_error_function(diagnostic_context*, char const*, diagnostic_info*)
 212 { untested();
 213 }
 214 void lhd_print_tree_nothing(FILE*, tree_node*, int)
 215 { SDCPP_DUMMY_FCT();
 216 }
 217 void lhd_set_decl_assembler_name(tree_node*)
 218 { SDCPP_DUMMY_FCT();
 219 }
 220 int lhd_tree_dump_type_quals(tree_node const*)
 221 { SDCPP_DUMMY_FCT();
 222         return 0;
 223 }
 224 size_t lhd_tree_size(tree_code)
 225 { SDCPP_DUMMY_FCT();
 226         return 0;
 227 }
 228 int lhd_type_dwarf_attribute(tree_node const*, int)
 229 { SDCPP_DUMMY_FCT();
 230         return 0;
 231 }
 232 bool names_builtin_p(char const*)
 233 { SDCPP_DUMMY_FCT();
 234         return 0;
 235 }
 236 void output_operand_lossage (const char *, ...)
 237 { SDCPP_DUMMY_FCT();
 238 }
 239 void parse_basever(int*, int*, int*)
 240 { SDCPP_DUMMY_FCT();
 241 }
 242 void pch_cpp_save_state()
 243 {
 244 }
 245 void pch_init()
 246 { SDCPP_DUMMY_FCT();
 247 }
 248 void pop_file_scope()
 249 { SDCPP_DUMMY_FCT();
 250 }
 251 void print_plugins_help(FILE*, char const*)
 252 {
 253         // no-op
 254 }
 255 void push_file_scope()
 256 { SDCPP_DUMMY_FCT();
 257 }
 258 tree pushdecl(tree_node*)
 259 { SDCPP_DUMMY_FCT();
 260         return 0;
 261 }
 262 void tree_diagnostics_defaults(diagnostic_context*)
 263 {
 264 }
 265 tree lhd_enum_underlying_base_type(tree_node const*)
 266 { SDCPP_DUMMY_FCT();
 267         return tree();
 268 }
 269 tree lhd_make_node(tree_code)
 270 { SDCPP_DUMMY_FCT();
 271         return tree();
 272 }
 273 tree* lhd_omp_get_decl_init(tree_node*)
 274 { SDCPP_DUMMY_FCT();
 275         return 0;
 276 }
 277 tree lhd_pass_through_t(tree_node*)
 278 { SDCPP_DUMMY_FCT();
 279         return tree();
 280 }
 281 void lhd_register_dumps(gcc::dump_manager*)
 282 { untested();
 283 }
 284 tree lhd_return_null_const_tree(tree_node const*)
 285 { SDCPP_DUMMY_FCT();
 286         return tree();
 287 }
 288 tree lhd_unit_size_without_reusable_padding(tree_node*)
 289 { SDCPP_DUMMY_FCT();
 290         return tree();
 291 }
 292 void statistics_early_init()
 293 {
 294 }
 295 void virt_loc_aware_diagnostic_finalizer(diagnostic_context*, diagnostic_info*)
 296 { untested();
 297 }
 298 void warn_if_plugins()
 299 { untested();
 300 }
 301 /*----------------------------------------------------------------------*/
 302 namespace gcc{
 303 pass_manager::~pass_manager ()
 304 { SDCPP_DUMMY_FCT();
 305 }
 306 pass_manager::pass_manager (context*)
 307 { SDCPP_DUMMY_FCT();
 308 }
 309 dump_manager::~dump_manager()
 310 { SDCPP_DUMMY_FCT();
 311 }
 312 dump_manager::dump_manager()
 313 {
 314 }
 315 }
 316 /*----------------------------------------------------------------------*/
 317 bool after_memory_report;
 318 FILE *dump_file = NULL;
 319 extern const struct attribute_spec c_common_format_attribute_table[] =
 320 {
 321   { "dummy",                 3, 3, false, true,  true, false,
 322                               NULL, NULL } };
 323 extern const struct attribute_spec c_common_attribute_table[] = {
 324         { "dummy",  1, 1, false, true, false, true,
 325                NULL, NULL } };
 326 struct ht *ident_hash;
 327 /*----------------------------------------------------------------------*/
 328 ggc_root_tab my_ggc_root_tab;
 329 const struct ggc_root_tab * const gt_ggc_deletable_rtab[] = { &my_ggc_root_tab };
 330 const struct ggc_root_tab * const gt_ggc_rtab[] = { &my_ggc_root_tab };
 331 const struct ggc_root_tab * const gt_pch_scalar_rtab[] = { &my_ggc_root_tab };
 332 /*----------------------------------------------------------------------*/
 333 bool this_is_asm_operands = 0;
 334 /*----------------------------------------------------------------------*/