/// ValidateRegisterVariable - Check that a static "asm" variable is /// well-formed. If not, emit error messages and return true. If so, return /// false. bool ValidateRegisterVariable(tree decl) { const char *Name = IDENTIFIER_POINTER(DECL_ASSEMBLER_NAME(decl)); int RegNumber = decode_reg_name(Name); const Type *Ty = ConvertType(TREE_TYPE(decl)); // If this has already been processed, don't emit duplicate error messages. if (DECL_LLVM_SET_P(decl)) { // Error state encoded into DECL_LLVM. return cast<ConstantInt>(DECL_LLVM(decl))->getZExtValue(); } /* Detect errors in declaring global registers. */ if (RegNumber == -1) error("%Jregister name not specified for %qD", decl, decl); else if (RegNumber < 0) error("%Jinvalid register name for %qD", decl, decl); else if (TYPE_MODE(TREE_TYPE(decl)) == BLKmode) error("%Jdata type of %qD isn%'t suitable for a register", decl, decl); #if 0 // FIXME: enable this. else if (!HARD_REGNO_MODE_OK(RegNumber, TYPE_MODE(TREE_TYPE(decl)))) error("%Jregister specified for %qD isn%'t suitable for data type", decl, decl); #endif else if (DECL_INITIAL(decl) != 0 && TREE_STATIC(decl)) error("global register variable has initial value"); else if (!Ty->isFirstClassType()) sorry("%JLLVM cannot handle register variable %qD, report a bug", decl, decl); else { if (TREE_THIS_VOLATILE(decl)) warning("volatile register variables don%'t work as you might wish"); SET_DECL_LLVM(decl, ConstantInt::getFalse()); return false; // Everything ok. } SET_DECL_LLVM(decl, ConstantInt::getTrue()); return true; }
void handle_common_deferred_options (void) { unsigned int i; cl_deferred_option *opt; vec<cl_deferred_option> v; if (common_deferred_options) v = *((vec<cl_deferred_option> *) common_deferred_options); else v = vNULL; if (flag_dump_all_passed) enable_rtl_dump_file (); if (flag_opt_info) opt_info_switch_p (NULL); FOR_EACH_VEC_ELT (v, i, opt) { switch (opt->opt_index) { case OPT_fcall_used_: fix_register (opt->arg, 0, 1); break; case OPT_fcall_saved_: fix_register (opt->arg, 0, 0); break; case OPT_fdbg_cnt_: dbg_cnt_process_opt (opt->arg); break; case OPT_fdbg_cnt_list: dbg_cnt_list_all_counters (); break; case OPT_fdebug_prefix_map_: add_debug_prefix_map (opt->arg); break; case OPT_fdump_: if (!g->get_dumps ()->dump_switch_p (opt->arg)) error ("unrecognized command line option %<-fdump-%s%>", opt->arg); break; case OPT_fopt_info_: if (!opt_info_switch_p (opt->arg)) error ("unrecognized command line option %<-fopt-info-%s%>", opt->arg); break; case OPT_fenable_: case OPT_fdisable_: if (opt->opt_index == OPT_fenable_) enable_pass (opt->arg); else disable_pass (opt->arg); break; case OPT_ffixed_: /* Deferred. */ fix_register (opt->arg, 1, 1); break; case OPT_fplugin_: #ifdef ENABLE_PLUGIN add_new_plugin (opt->arg); #else error ("plugin support is disabled; configure with --enable-plugin"); #endif break; case OPT_fplugin_arg_: #ifdef ENABLE_PLUGIN parse_plugin_arg_opt (opt->arg); #else error ("plugin support is disabled; configure with --enable-plugin"); #endif break; case OPT_frandom_seed: /* The real switch is -fno-random-seed. */ if (!opt->value) set_random_seed (NULL); break; case OPT_frandom_seed_: set_random_seed (opt->arg); break; case OPT_fstack_limit: /* The real switch is -fno-stack-limit. */ if (!opt->value) stack_limit_rtx = NULL_RTX; break; case OPT_fstack_limit_register_: { int reg = decode_reg_name (opt->arg); if (reg < 0) error ("unrecognized register name %qs", opt->arg); else stack_limit_rtx = gen_rtx_REG (Pmode, reg); } break; case OPT_fstack_limit_symbol_: stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg)); break; case OPT_fasan_shadow_offset_: if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS)) error ("-fasan-shadow-offset should only be used " "with -fsanitize=kernel-address"); if (!set_asan_shadow_offset (opt->arg)) error ("unrecognized shadow offset %qs", opt->arg); break; case OPT_fsanitize_sections_: set_sanitized_sections (opt->arg); break; default: gcc_unreachable (); } } }
static int common_handle_option (size_t scode, const char *arg, int value) { enum opt_code code = (enum opt_code) scode; switch (code) { /* APPLE LOCAL begin fat builds */ case OPT_arch: /* Ignore for now. */ break; /* APPLE LOCAL end fat builds */ case OPT__help: print_help (); exit_after_options = true; break; case OPT__param: handle_param (arg); break; case OPT__target_help: display_target_options (); exit_after_options = true; break; case OPT__version: print_version (stderr, ""); exit_after_options = true; break; case OPT_G: g_switch_value = value; g_switch_set = true; break; case OPT_O: case OPT_Os: /* Currently handled in a prescan. */ break; case OPT_W: /* For backward compatibility, -W is the same as -Wextra. */ set_Wextra (value); break; case OPT_Wextra: set_Wextra (value); break; case OPT_Wlarger_than_: larger_than_size = value; warn_larger_than = value != -1; break; case OPT_Wstrict_aliasing: case OPT_Wstrict_aliasing_: warn_strict_aliasing = value; break; case OPT_Wunused: set_Wunused (value); break; case OPT_aux_info: case OPT_aux_info_: aux_info_file_name = arg; flag_gen_aux_info = 1; break; case OPT_auxbase: aux_base_name = arg; break; /* APPLE LOCAL begin LLVM */ case OPT_mllvm: llvm_optns = arg; break; /* APPLE LOCAL end LLVM */ case OPT_auxbase_strip: { char *tmp = xstrdup (arg); strip_off_ending (tmp, strlen (tmp)); if (tmp[0]) aux_base_name = tmp; } break; case OPT_d: decode_d_option (arg); break; case OPT_dumpbase: dump_base_name = arg; break; /* APPLE LOCAL begin optimization pragmas 3124235/3420242 */ /* APPLE LOCAL end optimization pragmas 3124235/3420242 */ /* APPLE LOCAL begin falign-jumps-max-skip */ case OPT_falign_jumps_max_skip_: align_jumps_max_skip = value; break; case OPT_falign_loops_max_skip_: align_loops_max_skip = value; break; /* APPLE LOCAL end falign-jumps-max-skip */ /* APPLE LOCAL begin optimization pragmas 3124235/3420242 */ /* APPLE LOCAL end optimization pragmas 3124235/3420242 */ /* APPLE LOCAL begin predictive compilation */ case OPT_fpredictive_compilation: predictive_compilation = 0; break; case OPT_fpredictive_compilation_: { char* buf = xmalloc (strlen(arg) + 1); sprintf (buf, "%d", value); if (strcmp(buf, arg)) { error ("argument to \"-fpredictive-compilation=\" should be a valid non-negative integer instead of \"%s\"", arg); value = 0; } free(buf); predictive_compilation = value; break; } /* APPLE LOCAL end predictive compilation */ case OPT_fbranch_probabilities: flag_branch_probabilities_set = true; break; case OPT_fcall_used_: fix_register (arg, 0, 1); break; case OPT_fcall_saved_: fix_register (arg, 0, 0); break; case OPT_fdiagnostics_show_location_: if (!strcmp (arg, "once")) diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; else if (!strcmp (arg, "every-line")) diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE; else return 0; break; case OPT_fdump_: if (!dump_switch_p (arg)) return 0; break; case OPT_ffast_math: set_fast_math_flags (value); break; case OPT_ffixed_: fix_register (arg, 1, 1); break; case OPT_finline_limit_: case OPT_finline_limit_eq: set_param_value ("max-inline-insns-single", value / 2); set_param_value ("max-inline-insns-auto", value / 2); break; case OPT_fmessage_length_: pp_set_line_maximum_length (global_dc->printer, value); break; case OPT_fpack_struct_: if (value <= 0 || (value & (value - 1)) || value > 16) error("structure alignment must be a small power of two, not %d", value); else { initial_max_fld_align = value; maximum_field_alignment = value * BITS_PER_UNIT; } break; case OPT_fpeel_loops: flag_peel_loops_set = true; break; case OPT_fprofile_arcs: profile_arc_flag_set = true; break; /* APPLE LOCAL begin add fuse-profile */ case OPT_fuse_profile: /* APPLE LOCAL end add fuse-profile */ case OPT_fprofile_use: if (!flag_branch_probabilities_set) flag_branch_probabilities = value; if (!flag_profile_values_set) flag_profile_values = value; if (!flag_unroll_loops_set) flag_unroll_loops = value; if (!flag_peel_loops_set) flag_peel_loops = value; if (!flag_tracer_set) flag_tracer = value; if (!flag_value_profile_transformations_set) flag_value_profile_transformations = value; #ifdef HAVE_prefetch if (0 && !flag_speculative_prefetching_set) flag_speculative_prefetching = value; #endif break; /* APPLE LOCAL begin add fcreate-profile */ case OPT_fcreate_profile: /* APPLE LOCAL end add fcreate-profile */ case OPT_fprofile_generate: if (!profile_arc_flag_set) profile_arc_flag = value; if (!flag_profile_values_set) flag_profile_values = value; if (!flag_value_profile_transformations_set) flag_value_profile_transformations = value; if (!flag_unroll_loops_set) flag_unroll_loops = value; #ifdef HAVE_prefetch if (0 && !flag_speculative_prefetching_set) flag_speculative_prefetching = value; #endif break; case OPT_fprofile_values: flag_profile_values_set = true; break; case OPT_fvisibility_: { if (!strcmp(arg, "default")) default_visibility = VISIBILITY_DEFAULT; else if (!strcmp(arg, "internal")) default_visibility = VISIBILITY_INTERNAL; else if (!strcmp(arg, "hidden")) default_visibility = VISIBILITY_HIDDEN; else if (!strcmp(arg, "protected")) default_visibility = VISIBILITY_PROTECTED; else error ("unrecognised visibility value \"%s\"", arg); } break; case OPT_fvpt: flag_value_profile_transformations_set = true; break; case OPT_fspeculative_prefetching: flag_speculative_prefetching_set = true; break; case OPT_frandom_seed: /* The real switch is -fno-random-seed. */ if (value) return 0; flag_random_seed = NULL; break; case OPT_frandom_seed_: flag_random_seed = arg; break; /* APPLE LOCAL begin optimization pragmas 3124235/3420242 */ /* APPLE LOCAL end optimization pragmas 3124235/3420242 */ case OPT_fsched_stalled_insns_: flag_sched_stalled_insns = value; if (flag_sched_stalled_insns == 0) flag_sched_stalled_insns = -1; break; /* APPLE LOCAL begin optimization pragmas 3124235/3420242 */ /* APPLE LOCAL end optimization pragmas 3124235/3420242 */ case OPT_fstack_limit: /* The real switch is -fno-stack-limit. */ if (value) return 0; stack_limit_rtx = NULL_RTX; break; case OPT_fstack_limit_register_: { int reg = decode_reg_name (arg); if (reg < 0) error ("unrecognized register name \"%s\"", arg); else stack_limit_rtx = gen_rtx_REG (Pmode, reg); } break; case OPT_fstack_limit_symbol_: stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg)); break; case OPT_ftree_vectorizer_verbose_: vect_set_verbosity_level (arg); break; case OPT_ftls_model_: if (!strcmp (arg, "global-dynamic")) flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC; else if (!strcmp (arg, "local-dynamic")) flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC; else if (!strcmp (arg, "initial-exec")) flag_tls_default = TLS_MODEL_INITIAL_EXEC; else if (!strcmp (arg, "local-exec")) flag_tls_default = TLS_MODEL_LOCAL_EXEC; else warning ("unknown tls-model \"%s\"", arg); break; case OPT_ftracer: flag_tracer_set = true; break; case OPT_funroll_loops: flag_unroll_loops_set = true; break; /* APPLE LOCAL begin fwritable strings */ case OPT_fwritable_strings: flag_writable_strings = value; break; /* APPLE LOCAL end fwritable strings */ case OPT_g: set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg); break; case OPT_gcoff: set_debug_level (SDB_DEBUG, false, arg); break; case OPT_gdwarf_2: set_debug_level (DWARF2_DEBUG, false, arg); break; case OPT_ggdb: set_debug_level (NO_DEBUG, 2, arg); break; case OPT_gstabs: case OPT_gstabs_: set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg); break; case OPT_gvms: set_debug_level (VMS_DEBUG, false, arg); break; case OPT_gxcoff: case OPT_gxcoff_: set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg); break; case OPT_m: set_target_switch (arg); break; case OPT_o: asm_file_name = arg; break; case OPT_pedantic_errors: flag_pedantic_errors = pedantic = 1; break; default: /* If the flag was handled in a standard way, assume the lack of processing here is intentional. */ /* APPLE LOCAL optimization pragmas 3124235/3420242 */ if (cl_options[scode].flag_var || cl_options[scode].access_flag) break; abort (); } return 1; }
// make_decl_llvm - Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL // should have static storage duration. In other words, it should not be an // automatic variable, including PARM_DECLs. // // There is, however, one exception: this function handles variables explicitly // placed in a particular register by the user. // // This function corresponds to make_decl_rtl in varasm.c, and is implicitly // called by DECL_LLVM if a decl doesn't have an LLVM set. // void make_decl_llvm(tree decl) { #ifdef ENABLE_CHECKING // Check that we are not being given an automatic variable. // A weak alias has TREE_PUBLIC set but not the other bits. if (TREE_CODE(decl) == PARM_DECL || TREE_CODE(decl) == RESULT_DECL || (TREE_CODE(decl) == VAR_DECL && !TREE_STATIC(decl) && !TREE_PUBLIC(decl) && !DECL_EXTERNAL(decl) && !DECL_REGISTER(decl))) abort(); // And that we were not given a type or a label. */ else if (TREE_CODE(decl) == TYPE_DECL || TREE_CODE(decl) == LABEL_DECL) abort (); #endif // For a duplicate declaration, we can be called twice on the // same DECL node. Don't discard the LLVM already made. if (DECL_LLVM_SET_P(decl)) return; if (errorcount || sorrycount) return; // Do not process broken code. // Global register variable with asm name, e.g.: // register unsigned long esp __asm__("ebp"); if (TREE_CODE(decl) != FUNCTION_DECL && DECL_REGISTER(decl)) { // This just verifies that the variable is ok. The actual "load/store" // code paths handle accesses to the variable. ValidateRegisterVariable(decl); return; } timevar_push(TV_LLVM_GLOBALS); const char *Name = ""; if (DECL_NAME(decl)) if (tree AssemblerName = DECL_ASSEMBLER_NAME(decl)) Name = IDENTIFIER_POINTER(AssemblerName); // Now handle ordinary static variables and functions (in memory). // Also handle vars declared register invalidly. if (Name[0] == 1) { #ifdef REGISTER_PREFIX if (strlen (REGISTER_PREFIX) != 0) { int reg_number = decode_reg_name(Name); if (reg_number >= 0 || reg_number == -3) error("%Jregister name given for non-register variable %qD", decl, decl); } #endif } // Specifying a section attribute on a variable forces it into a // non-.bss section, and thus it cannot be common. if (TREE_CODE(decl) == VAR_DECL && DECL_SECTION_NAME(decl) != NULL_TREE && DECL_INITIAL(decl) == NULL_TREE && DECL_COMMON(decl)) DECL_COMMON(decl) = 0; // Variables can't be both common and weak. if (TREE_CODE(decl) == VAR_DECL && DECL_WEAK(decl)) DECL_COMMON(decl) = 0; // Okay, now we need to create an LLVM global variable or function for this // object. Note that this is quite possibly a forward reference to the // object, so its type may change later. if (TREE_CODE(decl) == FUNCTION_DECL) { assert(Name[0] && "Function with empty name!"); // If this function has already been created, reuse the decl. This happens // when we have something like __builtin_memset and memset in the same file. Function *FnEntry = TheModule->getFunction(Name); if (FnEntry == 0) { unsigned CC; const FunctionType *Ty = TheTypeConverter->ConvertFunctionType(TREE_TYPE(decl), decl, NULL, CC); FnEntry = new Function(Ty, Function::ExternalLinkage, Name, TheModule); FnEntry->setCallingConv(CC); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) FnEntry->setLinkage(Function::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(FnEntry,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) FnEntry->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) FnEntry->setVisibility(GlobalValue::ProtectedVisibility); } assert(FnEntry->getName() == Name &&"Preexisting fn with the same name!"); } SET_DECL_LLVM(decl, FnEntry); } else { assert((TREE_CODE(decl) == VAR_DECL || TREE_CODE(decl) == CONST_DECL) && "Not a function or var decl?"); const Type *Ty = ConvertType(TREE_TYPE(decl)); GlobalVariable *GV ; // If we have "extern void foo", make the global have type {} instead of // type void. if (Ty == Type::VoidTy) Ty = StructType::get(std::vector<const Type*>(), false); if (Name[0] == 0) { // Global has no name. GV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage, 0, "", TheModule); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) GV->setLinkage(GlobalValue::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(GV,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) GV->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) GV->setVisibility(GlobalValue::ProtectedVisibility); } } else { // If the global has a name, prevent multiple vars with the same name from // being created. GlobalVariable *GVE = TheModule->getGlobalVariable(Name); if (GVE == 0) { GV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage,0, Name, TheModule); // Check for external weak linkage if (DECL_EXTERNAL(decl) && DECL_WEAK(decl)) GV->setLinkage(GlobalValue::ExternalWeakLinkage); #ifdef TARGET_ADJUST_LLVM_LINKAGE TARGET_ADJUST_LLVM_LINKAGE(GV,decl); #endif /* TARGET_ADJUST_LLVM_LINKAGE */ // Handle visibility style if (TREE_PUBLIC(decl)) { if (DECL_VISIBILITY(decl) == VISIBILITY_HIDDEN) GV->setVisibility(GlobalValue::HiddenVisibility); else if (DECL_VISIBILITY(decl) == VISIBILITY_PROTECTED) GV->setVisibility(GlobalValue::ProtectedVisibility); } // If GV got renamed, then there is already an object with this name in // the symbol table. If this happens, the old one must be a forward // decl, just replace it with a cast of the new one. if (GV->getName() != Name) { Function *F = TheModule->getFunction(Name); assert(F && F->isDeclaration() && "A function turned into a global?"); // Replace any uses of "F" with uses of GV. Value *FInNewType = ConstantExpr::getBitCast(GV, F->getType()); F->replaceAllUsesWith(FInNewType); // Update the decl that points to F. changeLLVMValue(F, FInNewType); // Now we can give GV the proper name. GV->takeName(F); // F is now dead, nuke it. F->eraseFromParent(); } } else { GV = GVE; // Global already created, reuse it. } } if ((TREE_READONLY(decl) && !TREE_SIDE_EFFECTS(decl)) || TREE_CODE(decl) == CONST_DECL) { if (DECL_EXTERNAL(decl)) { // Mark external globals constant even though they could be marked // non-constant in the defining translation unit. The definition of the // global determines whether the global is ultimately constant or not, // marking this constant will allow us to do some extra (legal) // optimizations that we would otherwise not be able to do. (In C++, // any global that is 'C++ const' may not be readonly: it could have a // dynamic initializer. // GV->setConstant(true); } else { // Mark readonly globals with constant initializers constant. if (DECL_INITIAL(decl) != error_mark_node && // uninitialized? DECL_INITIAL(decl) && (TREE_CONSTANT(DECL_INITIAL(decl)) || TREE_CODE(DECL_INITIAL(decl)) == STRING_CST)) GV->setConstant(true); } } // Set thread local (TLS) if (TREE_CODE(decl) == VAR_DECL && DECL_THREAD_LOCAL(decl)) GV->setThreadLocal(true); SET_DECL_LLVM(decl, GV); } timevar_pop(TV_LLVM_GLOBALS); }