Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "int", "m32r_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ",", "frame_size", ";", "unsigned", "int", "gmask", ";", "enum", "m32r_function_type", "fn_type", ";", "int", "interrupt_p", ";", "int", "pic_reg_used", "=", "flag_pic", "&&", "(", "current_function_uses_pic_offset_table", "|", "current_function_profile", ")", ";", "var_size", "=", "M32R_STACK_ALIGN", "(", "size", ")", ";", "args_size", "=", "M32R_STACK_ALIGN", "(", "current_function_outgoing_args_size", ")", ";", "pretend_size", "=", "current_function_pretend_args_size", ";", "extra_size", "=", "FIRST_PARM_OFFSET", "(", "0", ")", ";", "total_size", "=", "extra_size", "+", "pretend_size", "+", "args_size", "+", "var_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "m32r_compute_function_type", "(", "current_function_decl", ")", ";", "interrupt_p", "=", "M32R_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "M32R_MAX_INT_REGS", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", "||", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "pic_reg_used", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "current_frame_info", ".", "save_fp", "=", "MUST_SAVE_FRAME_POINTER", ";", "current_frame_info", ".", "save_lr", "=", "MUST_SAVE_RETURN_ADDR", "||", "pic_reg_used", ";", "reg_size", "+=", "(", "(", "current_frame_info", ".", "save_fp", "+", "current_frame_info", ".", "save_lr", ")", "*", "UNITS_PER_WORD", ")", ";", "total_size", "+=", "reg_size", ";", "total_size", "=", "M32R_STACK_ALIGN", "(", "total_size", ")", ";", "frame_size", "=", "total_size", "-", "(", "pretend_size", "+", "reg_size", ")", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "extra_size", "=", "extra_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "gmask", "=", "gmask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "m32r", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "virtual", "const", "PPCInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "bool", "valid_src_p", "(", "rtx", "src", ",", "rtx_insn", "*", "insn", ",", "struct", "loop", "*", "loop", ",", "bool", "*", "pre_post", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ",", "bool", "load_pair", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "rtx", "x", "=", "NULL_RTX", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "src", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "{", "x", "=", "*", "iter", ";", "break", ";", "}", "if", "(", "!", "x", ")", "return", "false", ";", "struct", "aarch64_address_info", "addr", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "!", "aarch64_classify_address", "(", "&", "addr", ",", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "true", ")", ")", "return", "false", ";", "if", "(", "addr", ".", "type", "!=", "ADDRESS_REG_IMM", "&&", "addr", ".", "type", "!=", "ADDRESS_REG_WB", "&&", "addr", ".", "type", "!=", "ADDRESS_REG_REG", "&&", "addr", ".", "type", "!=", "ADDRESS_REG_UXTW", "&&", "addr", ".", "type", "!=", "ADDRESS_REG_SXTW", ")", "return", "false", ";", "unsigned", "regno", "=", "REGNO", "(", "addr", ".", "base", ")", ";", "if", "(", "global_regs", "[", "regno", "]", "||", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "addr", ".", "type", "==", "ADDRESS_REG_WB", ")", "{", "unsigned", "code", "=", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "*", "pre_post", "=", "true", ";", "*", "base", "=", "addr", ".", "base", ";", "if", "(", "code", "==", "PRE_MODIFY", "||", "code", "==", "POST_MODIFY", ")", "*", "offset", "=", "addr", ".", "offset", ";", "else", "{", "unsigned", "int_offset", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "load_pair", "&&", "(", "code", "==", "POST_INC", "||", "code", "==", "POST_DEC", ")", ")", "int_offset", "*=", "2", ";", "*", "offset", "=", "GEN_INT", "(", "int_offset", ")", ";", "}", "return", "true", ";", "}", "else", "if", "(", "addr", ".", "type", "==", "ADDRESS_REG_IMM", "||", "addr", ".", "type", "==", "ADDRESS_REG_REG", ")", "{", "if", "(", "!", "iv_p", "(", "insn", ",", "addr", ".", "base", ",", "loop", ")", ")", "return", "false", ";", "*", "base", "=", "addr", ".", "base", ";", "*", "offset", "=", "addr", ".", "offset", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "SRC", "is", "a", "strided", "load", "in", "the", "LOOP", ",", "false", "otherwise", ".", "If", "it", "is", "a", "strided", "load", ",", "set", "the", "BASE", "and", "OFFSET", ".", "Also", ",", "if", "this", "is", "a", "pre/post", "increment", "load", ",", "set", "PRE_POST", "to", "true", "." ]

[ "aarch64", "0", "0", "2" ]

[]

[ "<s>", "static", "void", "m68k_asm_final_postscan_insn", "(", "FILE", "*", ",", "rtx_insn", "*", "insn", ",", "rtx", "[", "]", ",", "int", ")", "{", "enum", "attr_flags_valid", "v", "=", "get_attr_flags_valid", "(", "insn", ")", ";", "if", "(", "v", "==", "FLAGS_VALID_SET", ")", "return", ";", "flags_compare_op0", "=", "flags_compare_op1", "=", "NULL_RTX", ";", "if", "(", "v", "==", "FLAGS_VALID_NO", ")", "{", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "return", ";", "}", "else", "if", "(", "v", "==", "FLAGS_VALID_UNCHANGED", ")", "{", "if", "(", "flags_operand1", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand1", ",", "insn", ")", ")", "flags_operand1", "=", "NULL_RTX", ";", "if", "(", "flags_operand2", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand2", ",", "insn", ")", ")", "flags_operand2", "=", "NULL_RTX", ";", "return", ";", "}", "flags_valid", "=", "v", ";", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "side_effects_p", "(", "dest", ")", ")", "dest", "=", "NULL_RTX", ";", "switch", "(", "v", ")", "{", "case", "FLAGS_VALID_YES", ":", "case", "FLAGS_VALID_NOOV", ":", "flags_operand1", "=", "dest", ";", "flags_operand2", "=", "NULL_RTX", ";", "break", ";", "case", "FLAGS_VALID_MOVE", ":", "if", "(", "dest", "!=", "NULL_RTX", "&&", "!", "FP_REG_P", "(", "dest", ")", "&&", "(", "FP_REG_P", "(", "src", ")", "||", "GET_CODE", "(", "src", ")", "==", "FIX", "||", "FLOAT_MODE_P", "(", "GET_MODE", "(", "dest", ")", ")", ")", ")", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "else", "{", "flags_operand1", "=", "dest", ";", "if", "(", "GET_MODE", "(", "src", ")", "!=", "VOIDmode", "&&", "!", "side_effects_p", "(", "src", ")", "&&", "!", "modified_in_p", "(", "src", ",", "insn", ")", ")", "flags_operand2", "=", "src", ";", "else", "flags_operand2", "=", "NULL_RTX", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Process", "INSN", "to", "remember", "flag", "operands", "if", "possible", "." ]

[ "m68k" ]

[]

[ "<s>", "static", "rtx", "moxie_static_chain", "(", "const_tree", "ARG_UNUSED", "(", "fndecl_or_type", ")", ",", "bool", "incoming_p", ")", "{", "rtx", "addr", ",", "mem", ";", "if", "(", "incoming_p", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "else", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "return", "mem", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_STATIC_CHAIN", "." ]

[ "moxie", "2", "1" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "Ty", "->", "getTypeID", "(", ")", "==", "Type", "::", "VoidTyID", ")", "return", "AM", ".", "Scale", "==", "0", "&&", "isImmUs", "(", "AM", ".", "BaseOffs", ")", "&&", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "unsigned", "Size", "=", "TD", "->", "getTypeAllocSize", "(", "Ty", ")", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "Size", ">=", "4", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "%", "4", "==", "0", ";", "}", "switch", "(", "Size", ")", "{", "case", "1", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "2", ":", "case", "3", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs2", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "2", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "default", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "4", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "XCore", "XCore", "0", "4", "0", "4", "0", "1", "0", "1", "0", "2", "3", "0", "2", "0", "0", "4", "0" ]

[]

[ "<s>", "bool", "WebAssemblyStoreResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Store Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "MRI", ".", "isSSA", "(", ")", "&&", "\"StoreResults depends on SSA form\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "{", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "FromReg", "=", "MI", ".", "getOperand", "(", "WebAssembly", "::", "StoreValueOperandNo", ")", ".", "getReg", "(", ")", ";", "Changed", "|=", "ReplaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ")", ";", "break", ";", "}", "case", "WebAssembly", "::", "CALL_I32", ":", "case", "WebAssembly", "::", "CALL_I64", ":", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op1", ".", "isSymbol", "(", ")", ")", "{", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "if", "(", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ")", "{", "LibFunc", "::", "Func", "Func", ";", "if", "(", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "{", "const", "auto", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "Op2", ".", "isReg", "(", ")", ")", "{", "unsigned", "FromReg", "=", "Op2", ".", "getReg", "(", ")", ";", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FromReg", ")", "!=", "MRI", ".", "getRegClass", "(", "ToReg", ")", ")", "report_fatal_error", "(", "\"Store results: call to builtin function \"", "\"with wrong signature, from/to mismatch\"", ")", ";", "Changed", "|=", "ReplaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ")", ";", "}", "else", "if", "(", "Op2", ".", "isFI", "(", ")", ")", "{", "break", ";", "}", "else", "{", "report_fatal_error", "(", "\"Store results: call to builtin function \"", "\"with wrong signature, not consuming reg or \"", "\"frame index\"", ")", ";", "}", "}", "}", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Store Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"StoreResults depends on SSA form\"", "\"Basic Block: \"", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "0", "WebAssembly::StoreValueOperandNo", "WebAssembly::CALL_I32", "WebAssembly::CALL_I64", "1", "2", "0", "\"Store results: call to builtin function \"", "\"with wrong signature, from/to mismatch\"", "\"Store results: call to builtin function \"", "\"with wrong signature, not consuming reg or \"", "\"frame index\"" ]

[]

[ "<s>", "int", "arm_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "(", "regno", "==", "CC_REGNUM", "||", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", "&&", "regno", "==", "VFPCC_REGNUM", ")", ")", ";", "if", "(", "TARGET_THUMB", ")", "return", "(", "ARM_NUM_REGS", "(", "mode", ")", "<", "2", ")", "||", "(", "regno", "<", "LAST_LO_REGNUM", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_MAVERICK", "&&", "IS_CIRRUS_REGNUM", "(", "regno", ")", ")", "return", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "||", "(", "mode", "==", "DImode", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", "&&", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "TRUE", ";", "if", "(", "mode", "==", "DFmode", ")", "return", "(", "(", "regno", "-", "FIRST_VFP_REGNUM", ")", "&", "1", ")", "==", "0", ";", "return", "FALSE", ";", "}", "if", "(", "TARGET_REALLY_IWMMXT", ")", "{", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ";", "}", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", ")", "return", "!", "(", "TARGET_LDRD", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ";", "return", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPA", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "regno", ">=", "FIRST_FPA_REGNUM", "&&", "regno", "<=", "LAST_FPA_REGNUM", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "REGNO", "is", "a", "valid", "register", "for", "holding", "a", "quantity", "of", "type", "MODE", "." ]

[ "arm", "2", "1", "0", "4", "1", "0" ]

[]

[ "<s>", "static", "int", "m68k_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "def_insn", ",", "int", "cost", ")", "{", "int", "delay", ";", "if", "(", "recog_memoized", "(", "def_insn", ")", "<", "0", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "cost", ";", "if", "(", "sched_cfv4_bypass_data", ".", "scale", "==", "1", ")", "{", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "def_insn", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "insn", ")", ";", "if", "(", "cost", "<", "3", ")", "cost", "=", "3", ";", "sched_cfv4_bypass_data", ".", "pro", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "con", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "scale", "=", "0", ";", "}", "else", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "scale", "==", "0", ")", ";", "delay", "=", "min_insn_conflict_delay", "(", "sched_adjust_cost_state", ",", "def_insn", ",", "insn", ")", ";", "if", "(", "delay", ">", "cost", ")", "cost", "=", "delay", ";", "return", "cost", ";", "}", "</s>" ]

[ "Implement", "adjust_cost", "scheduler", "hook", ".", "Return", "adjusted", "COST", "of", "dependency", "LINK", "between", "DEF_INSN", "and", "INSN", "." ]

[ "m68k", "0", "0", "1", "3", "3", "0", "0" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_vmx_dform", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_VMX", "]", "&", "RELOAD_REG_OFFSET", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "have", "D-form", "addressing", "in", "altivec", "registers", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "static", "bool", "split_stack_arg_pointer_used_p", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "!=", "NULL_RTX", "&&", "(", "!", "REG_P", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "||", "(", "REGNO", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ")", ")", "return", "true", ";", "rtx_insn", "*", "insn", ";", "basic_block", "bb", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "next_bb", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "df_ref", "use", ";", "FOR_EACH_INSN_USE", "(", "use", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "use", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "true", ";", "}", "df_ref", "def", ";", "FOR_EACH_INSN_DEF", "(", "def", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "def", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "false", ";", "}", "}", "return", "bitmap_bit_p", "(", "DF_LR_OUT", "(", "bb", ")", ",", "12", ")", ";", "}", "</s>" ]

[ "Return", "whether", "the", "split-stack", "arg", "pointer", "(", "r12", ")", "is", "used", "." ]

[ "powerpcspe", "12", "12", "12" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "duplicate", "(", "MachineInstr", "*", "Orig", ",", "MachineFunction", "&", "MF", ")", "const", "{", "MachineInstr", "*", "MI", "=", "TargetInstrInfoImpl", "::", "duplicate", "(", "Orig", ",", "MF", ")", ";", "switch", "(", "Orig", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "unsigned", "CPI", "=", "Orig", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "Orig", "->", "getOperand", "(", "1", ")", ".", "setIndex", "(", "CPI", ")", ";", "Orig", "->", "getOperand", "(", "2", ")", ".", "setImm", "(", "PCLabelId", ")", ";", "break", ";", "}", "}", "return", "MI", ";", "}", "</s>" ]

[ "Clones", "instruction", "or", "the", "whole", "instruction", "bundle", "Orig", "and", "insert", "into", "MBB", "before", "InsertBefore", "." ]

[ "ARM", "ARM", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1", "1", "2" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "dl", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Only GPR32 src copy supported.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "\"Only GPR32 dest copy supported.\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "MOV_rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "ARC", "ARC", "ARC::GPR32RegClass", "\"Only GPR32 src copy supported.\"", "ARC::GPR32RegClass", "\"Only GPR32 dest copy supported.\"", "ARC::MOV_rr" ]

[]

[ "<s>", "static", "bool", "arc_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "(", "arg", ".", "type", "!=", "0", "&&", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "arg", ".", "type", ")", ")", "!=", "INTEGER_CST", "||", "TREE_ADDRESSABLE", "(", "arg", ".", "type", ")", ")", ")", ";", "}", "</s>" ]

[ "For", "ARC", ",", "All", "aggregates", "and", "arguments", "greater", "than", "8", "bytes", "are", "passed", "by", "reference", "." ]

[ "arc", "0" ]

[]

[ "<s>", "bool", "AMDGPUPrintfRuntimeBinding", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "return", "false", ";", "auto", "PrintfFunction", "=", "M", ".", "getFunction", "(", "\"printf\"", ")", ";", "if", "(", "!", "PrintfFunction", ")", "return", "false", ";", "for", "(", "auto", "&", "U", ":", "PrintfFunction", "->", "uses", "(", ")", ")", "{", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "if", "(", "CI", "->", "isCallee", "(", "&", "U", ")", ")", "Printfs", ".", "push_back", "(", "CI", ")", ";", "}", "}", "if", "(", "Printfs", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "HostcallFunction", "=", "M", ".", "getFunction", "(", "\"__ockl_hostcall_internal\"", ")", ")", "{", "for", "(", "auto", "&", "U", ":", "HostcallFunction", "->", "uses", "(", ")", ")", "{", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "M", ".", "getContext", "(", ")", ".", "emitError", "(", "CI", ",", "\"Cannot use both printf and hostcall in the same module\"", ")", ";", "}", "}", "}", "TD", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "auto", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "auto", "GetTLI", "=", "[", "this", "]", "(", "Function", "&", "F", ")", "->", "TargetLibraryInfo", "&", "{", "return", "this", "->", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "}", ";", "return", "lowerPrintfForGpu", "(", "M", ",", "GetTLI", ")", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "\"printf\"", "\"__ockl_hostcall_internal\"", "\"Cannot use both printf and hostcall in the same module\"" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Mips", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Mips", "::", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "RA", ",", "MVT", "::", "i32", ")", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "RA", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "0", "0", "\"Can only return in registers!\"", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0", "1", "MipsISD::Ret", "MVT::Other", "Mips::RA", "MVT::i32", "MipsISD::Ret", "MVT::Other", "Mips::RA", "MVT::i32" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastLowerCall", "(", "CallLoweringInfo", "&", "CLI", ")", "{", "CallingConv", "::", "ID", "CC", "=", "CLI", ".", "CallConv", ";", "bool", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "Value", "*", "Callee", "=", "CLI", ".", "Callee", ";", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "MVT", "RetVT", ";", "if", "(", "CLI", ".", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeLegal", "(", "CLI", ".", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isInReg", "(", ")", "||", "Flag", ".", "isSRet", "(", ")", "||", "Flag", ".", "isNest", "(", ")", "||", "Flag", ".", "isByVal", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "16", ">", "OutVTs", ";", "OutVTs", ".", "reserve", "(", "CLI", ".", "OutVals", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "*", "Val", ":", "CLI", ".", "OutVals", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "64", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "unsigned", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "return", "finishCall", "(", "CLI", ",", "RetVT", ",", "NumBytes", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "call", "lowering", "." ]

[ "Mips", "Mips", "MVT::isVoid", "16", "MVT::i1", "MVT::i8", "MVT::i16", "64", "MVT::i32", "Mips::T9", "Mips::JALR", "Mips::RA", "Mips::T9" ]

[]

[ "<s>", "void", "AArch64_ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SupportDebugThreadLocalLocation", "=", "false", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "HOST_WIDE_INT", "alpha_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "ret", ";", "ret", "=", "alpha_sa_size", "(", ")", ";", "ret", "+=", "ALPHA_ROUND", "(", "current_function_outgoing_args_size", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_pretend_args_size", ")", "-", "current_function_pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "rs6000_is_valid_2insn_and", "(", "rtx", "c", ",", "machine_mode", "mode", ")", "{", "if", "(", "rs6000_is_valid_mask", "(", "c", ",", "NULL", ",", "NULL", ",", "mode", ")", ")", "return", "true", ";", "unsigned", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "c", ")", ";", "unsigned", "HOST_WIDE_INT", "bit1", "=", "val", "&", "-", "val", ";", "unsigned", "HOST_WIDE_INT", "bit2", "=", "(", "val", "+", "bit1", ")", "&", "~", "val", ";", "unsigned", "HOST_WIDE_INT", "val1", "=", "(", "val", "+", "bit1", ")", "&", "val", ";", "unsigned", "HOST_WIDE_INT", "bit3", "=", "val1", "&", "-", "val1", ";", "return", "rs6000_is_valid_and_mask", "(", "GEN_INT", "(", "val", "+", "bit3", "-", "bit2", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "whether", "an", "AND", "with", "C", "(", "a", "CONST_INT", ")", "in", "mode", "MODE", "can", "be", "done", "using", "two", "machine", "instructions", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "(", "ST", "->", "hasAVX512", "(", ")", "||", "(", "ST", "->", "hasFastGather", "(", ")", "&&", "ST", "->", "hasAVX2", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "DataVTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "DataTy", ")", ")", "{", "unsigned", "NumElts", "=", "DataVTy", "->", "getNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "1", "||", "!", "isPowerOf2_32", "(", "NumElts", ")", ")", "return", "false", ";", "}", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "X86", "X86", "1", "32", "64" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCAssignFnForNode", "(", "CallConv", ",", "true", ",", "isVarArg", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "ARM", "ARM", "ISD::OutputArg", "16" ]

[]

[ "<s>", "static", "const", "char", "*", "s390_branch_condition_mnemonic", "(", "rtx", "code", ",", "int", "inv", ")", "{", "int", "mask", ";", "static", "const", "char", "*", "const", "mnemonic", "[", "16", "]", "=", "{", "NULL", ",", "\"o\"", ",", "\"h\"", ",", "\"nle\"", ",", "\"l\"", ",", "\"nhe\"", ",", "\"lh\"", ",", "\"ne\"", ",", "\"e\"", ",", "\"nlh\"", ",", "\"he\"", ",", "\"nl\"", ",", "\"le\"", ",", "\"nh\"", ",", "\"no\"", ",", "NULL", "}", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "code", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "code", ",", "0", ")", ")", "==", "CC_REGNUM", "&&", "(", "XEXP", "(", "code", ",", "1", ")", "==", "const0_rtx", "||", "(", "GET_MODE", "(", "XEXP", "(", "code", ",", "0", ")", ")", "==", "CCRAWmode", "&&", "CONST_INT_P", "(", "XEXP", "(", "code", ",", "1", ")", ")", ")", ")", ")", "mask", "=", "s390_branch_condition_mask", "(", "code", ")", ";", "else", "mask", "=", "s390_compare_and_branch_condition_mask", "(", "code", ")", ";", "gcc_assert", "(", "mask", ">=", "0", ")", ";", "if", "(", "inv", ")", "mask", "^=", "15", ";", "gcc_assert", "(", "mask", ">=", "1", "&&", "mask", "<=", "14", ")", ";", "return", "mnemonic", "[", "mask", "]", ";", "}", "</s>" ]

[ "If", "INV", "is", "false", ",", "return", "assembler", "mnemonic", "string", "to", "implement", "a", "branch", "specified", "by", "CODE", ".", "If", "INV", "is", "true", ",", "return", "mnemonic", "for", "the", "corresponding", "inverted", "branch", "." ]

[ "s390", "16", "\"o\"", "\"h\"", "\"nle\"", "\"l\"", "\"nhe\"", "\"lh\"", "\"ne\"", "\"e\"", "\"nlh\"", "\"he\"", "\"nl\"", "\"le\"", "\"nh\"", "\"no\"", "0", "0", "1", "0", "1", "0", "15", "1", "14" ]

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "*", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "}", "return", "Changes", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "R600", "SI", "SI", "SI", "0", "0" ]

[]

[ "<s>", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "NVPTX" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "int", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "SizeA", "=", "0", ",", "SizeB", "=", "0", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "&", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "&", "MIb", ")", ")", "return", "true", ";", "unsigned", "BaseRegA", "=", "getBaseAndOffset", "(", "&", "MIa", ",", "OffsetA", ",", "SizeA", ")", ";", "if", "(", "!", "BaseRegA", "||", "!", "SizeA", ")", "return", "false", ";", "unsigned", "BaseRegB", "=", "getBaseAndOffset", "(", "&", "MIb", ",", "OffsetB", ",", "SizeB", ")", ";", "if", "(", "!", "BaseRegB", "||", "!", "SizeB", ")", "return", "false", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", ")", "return", "false", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "offDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "(", "SizeB", "<=", "offDiff", ")", ";", "}", "else", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "offDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "(", "SizeA", "<=", "offDiff", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Hexagon", "Hexagon", "0", "0", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"XCore FRAME_TO_ARGS_OFFSET Elimination\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "XCore", "\"XCore FRAME_TO_ARGS_OFFSET Elimination\"" ]

[]

[ "<s>", "void", "TMS320C64XHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "ResourceAssignment", "::", "AdvanceCycle", "(", ")", ";", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "TMS320C64X", "TMS320C64X" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "assert", "(", "0", "&&", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::STri", "0", "SP::FPRegsRegisterClass", "SP::STFri", "0", "SP::DFPRegsRegisterClass", "SP::STDFri", "0", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "2", ",", "-", "4", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FPW register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "MSP430", "MSP430", "2", "4", "\"Slot for FPW register must be last in order to be found!\"" ]

[]

[ "<s>", "int", "cris_side_effect_mode_ok", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "ops", ",", "int", "lreg", ",", "int", "rreg", ",", "int", "rval", ",", "int", "multop", ",", "int", "other_op", ")", "{", "int", "mult", "=", "multop", "<", "0", "?", "1", ":", "INTVAL", "(", "ops", "[", "multop", "]", ")", ";", "rtx", "reg_rtx", "=", "ops", "[", "rreg", "]", ";", "rtx", "val_rtx", "=", "ops", "[", "rval", "]", ";", "if", "(", "!", "BASE_P", "(", "reg_rtx", ")", ")", "reg_rtx", "=", "val_rtx", ",", "val_rtx", "=", "ops", "[", "rreg", "]", ";", "if", "(", "!", "BASE_P", "(", "reg_rtx", ")", ")", "return", "0", ";", "if", "(", "!", "TARGET_SIDE_EFFECT_PREFIXES", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "MULT", ")", "{", "mult", "=", "INTVAL", "(", "XEXP", "(", "val_rtx", ",", "1", ")", ")", ";", "val_rtx", "=", "XEXP", "(", "val_rtx", ",", "0", ")", ";", "code", "=", "MULT", ";", "}", "if", "(", "other_op", ">=", "0", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ops", "[", "other_op", "]", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "(", "BASE_P", "(", "ops", "[", "lreg", "]", ")", "&&", "BASE_P", "(", "ops", "[", "other_op", "]", ")", "&&", "REGNO", "(", "ops", "[", "lreg", "]", ")", "==", "REGNO", "(", "ops", "[", "other_op", "]", ")", ")", "||", "rtx_equal_p", "(", "ops", "[", "other_op", "]", ",", "ops", "[", "lreg", "]", ")", ")", "return", "0", ";", "}", "if", "(", "ops", "[", "lreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rval", "]", "==", "frame_pointer_rtx", "||", "(", "other_op", ">=", "0", "&&", "ops", "[", "other_op", "]", "==", "frame_pointer_rtx", ")", ")", "return", "0", ";", "if", "(", "code", "==", "PLUS", "&&", "!", "BASE_P", "(", "val_rtx", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "&&", "GET_CODE", "(", "val_rtx", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "val_rtx", ")", "<=", "63", "&&", "INTVAL", "(", "val_rtx", ")", ">=", "-", "63", ")", ")", "return", "0", ";", "if", "(", "CONSTANT_P", "(", "val_rtx", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "MEM", "&&", "BASE_OR_AUTOINCR_P", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "SIGN_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ")", "==", "MEM", "&&", "BASE_OR_AUTOINCR_P", "(", "XEXP", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ",", "0", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "else", "if", "(", "code", "==", "MULT", "||", "(", "code", "==", "PLUS", "&&", "BASE_P", "(", "val_rtx", ")", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "||", "(", "mult", "==", "1", "&&", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "val_rtx", ")", ")", ")", "return", "0", ";", "if", "(", "mult", "!=", "1", "&&", "mult", "!=", "2", "&&", "mult", "!=", "4", ")", "return", "0", ";", "if", "(", "!", "BASE_P", "(", "reg_rtx", ")", ")", "return", "0", ";", "return", "1", ";", "}", "internal_error", "(", "\"internal error: cris_side_effect_mode_ok with bad operands\"", ")", ";", "}", "</s>" ]

[ "Check", "various", "objections", "to", "the", "side-effect", ".", "Used", "in", "the", "test-part", "of", "an", "anonymous", "insn", "describing", "an", "insn", "with", "a", "possible", "side-effect", ".", "Returns", "nonzero", "if", "the", "implied", "side-effect", "is", "ok.", "code", ":", "PLUS", "or", "MULT", "ops", ":", "An", "array", "of", "rtx", ":", "es", ".", "lreg", ",", "rreg", ",", "rval", ",", "The", "variables", "multop", "and", "other_op", "are", "indexes", "into", "this", ",", "or", "-1", "if", "they", "are", "not", "applicable", ".", "lreg", ":", "The", "register", "that", "gets", "assigned", "in", "the", "side-effect", ".", "rreg", ":", "One", "register", "in", "the", "side-effect", "expression", "rval", ":", "The", "other", "register", ",", "or", "an", "int", ".", "multop", ":", "An", "integer", "to", "multiply", "rval", "with", ".", "other_op", ":", "One", "of", "the", "entities", "of", "the", "main", "effect", ",", "whose", "mode", "we", "must", "consider", "." ]

[ "cris", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "63", "63", "0", "1", "0", "1", "0", "0", "0", "1", "0", "1", "0", "1", "2", "4", "0", "0", "1", "\"internal error: cris_side_effect_mode_ok with bad operands\"" ]

[]

[ "<s>", "std", "::", "string", "str", "(", ")", "const", "{", "std", "::", "string", "S", ";", "raw_string_ostream", "OS", "(", "S", ")", ";", "OS", "<<", "\"{\"", ";", "StartInst", "->", "print", "(", "OS", ",", "true", ")", ";", "OS", "<<", "\" -> \"", ";", "LastInst", "->", "print", "(", "OS", ",", "true", ")", ";", "if", "(", "KillInst", ")", "{", "OS", "<<", "\" (kill @ \"", ";", "KillInst", "->", "print", "(", "OS", ",", "true", ")", ";", "OS", "<<", "\")\"", ";", "}", "OS", "<<", "\"}\"", ";", "return", "OS", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "twine", "contents", "as", "a", "std", ":", ":string", "." ]

[ "AArch64", "\"{\"", "\" -> \"", "\" (kill @ \"", "\")\"", "\"}\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "LanaiRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "getGPRsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RET32", ":", "case", "X86", "::", "RET64", ":", "case", "X86", "::", "RETI32", ":", "case", "X86", "::", "RETI64", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "I", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", "&&", "CS", "!=", "X86", "::", "RIP", "&&", "CS", "!=", "X86", "::", "RSP", "&&", "CS", "!=", "X86", "::", "ESP", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "X86", "0", "0", "0", "X86::RET", "X86::RET32", "X86::RET64", "X86::RETI32", "X86::RETI64", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "X86::RIP", "X86::RSP", "X86::ESP", "0" ]

[]

[ "<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "4", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "S_MODE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "D_MODE", ")", ";", "else", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPUEmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "arc_mode_class", "array", "." ]

[ "arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<", "0", "&&", "\"Local offset must be negative\"", ")", ";", "unsigned", "OpC", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ")", "return", "false", ";", "if", "(", "(", "OpC", "==", "PPC", "::", "ADDI", "||", "OpC", "==", "PPC", "::", "ADDI8", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "StackEst", "=", "PPCFI", "->", "determineFrameLayout", "(", "MF", ",", "false", ",", "true", ")", ";", "if", "(", "!", "StackEst", ")", "return", "false", ";", "Offset", "+=", "StackEst", ";", "return", "!", "isFrameOffsetLegal", "(", "MI", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "PowerPC", "PPC", "0", "\"Local offset must be negative\"", "PPC::ADDI", "PPC::ADDI8", "2", "0", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "int", "microblaze_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "COSTS_N_INSNS", "(", "microblaze_address_insns", "(", "addr", ",", "GET_MODE", "(", "addr", ")", ")", ")", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

[ "microblaze" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "MachineOperand", "&", "MO", "=", "Cond", "[", "1", "]", ";", "switch", "(", "MO", ".", "getImm", "(", ")", ")", "{", "case", "R600", "::", "PRED_SETE_INT", ":", "MO", ".", "setImm", "(", "R600", "::", "PRED_SETNE_INT", ")", ";", "break", ";", "case", "R600", "::", "PRED_SETNE_INT", ":", "MO", ".", "setImm", "(", "R600", "::", "PRED_SETE_INT", ")", ";", "break", ";", "case", "R600", "::", "PRED_SETE", ":", "MO", ".", "setImm", "(", "R600", "::", "PRED_SETNE", ")", ";", "break", ";", "case", "R600", "::", "PRED_SETNE", ":", "MO", ".", "setImm", "(", "R600", "::", "PRED_SETE", ")", ";", "break", ";", "default", ":", "return", "true", ";", "}", "MachineOperand", "&", "MO2", "=", "Cond", "[", "2", "]", ";", "switch", "(", "MO2", ".", "getReg", "(", ")", ")", "{", "case", "R600", "::", "PRED_SEL_ZERO", ":", "MO2", ".", "setReg", "(", "R600", "::", "PRED_SEL_ONE", ")", ";", "break", ";", "case", "R600", "::", "PRED_SEL_ONE", ":", "MO2", ".", "setReg", "(", "R600", "::", "PRED_SEL_ZERO", ")", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "AMDGPU", "R600", "1", "R600::PRED_SETE_INT", "R600::PRED_SETNE_INT", "R600::PRED_SETNE_INT", "R600::PRED_SETE_INT", "R600::PRED_SETE", "R600::PRED_SETNE", "R600::PRED_SETNE", "R600::PRED_SETE", "2", "R600::PRED_SEL_ZERO", "R600::PRED_SEL_ONE", "R600::PRED_SEL_ONE", "R600::PRED_SEL_ZERO" ]

[]

[ "<s>", "static", "int", "csky_num_arg_regs", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "is_stdarg", ")", "{", "int", "size", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_HARD_FLOAT_ABI", "&&", "!", "is_stdarg", ")", "{", "if", "(", "CSKY_VREG_MODE_P", "(", "mode", ")", "&&", "!", "TARGET_SINGLE_FPU", ")", "return", "(", "(", "CSKY_NUM_WORDS", "(", "size", ")", "+", "1", ")", "/", "2", ")", ";", "}", "return", "CSKY_NUM_WORDS", "(", "size", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "registers", "(", "words", ")", "needed", "to", "pass", "an", "argument", "of", "MODE", "and", "TYPE", "." ]

[ "csky", "1", "2" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasLiveCondCodeDef", "(", "MachineInstr", "&", "MI", ")", "const", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "!", "MO", ".", "isDead", "(", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "MI", "has", "a", "condition", "code", "def", ",", "e.g", "." ]

[ "X86", "X86", "X86::EFLAGS" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIModeRegisterPass", "(", ")", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "&", "SIRemoveShortExecBranchesID", ")", ";", "addPass", "(", "&", "SIPreEmitPeepholeID", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "mips_expand_vec_perm_const", "(", "rtx", "operands", "[", "4", "]", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "int", "i", ",", "nelt", ",", "which", ";", "unsigned", "char", "orig_perm", "[", "MAX_VECT_LEN", "]", ";", "rtx", "sel", ";", "bool", "ok", ";", "d", ".", "target", "=", "operands", "[", "0", "]", ";", "d", ".", "op0", "=", "operands", "[", "1", "]", ";", "d", ".", "op1", "=", "operands", "[", "2", "]", ";", "sel", "=", "operands", "[", "3", "]", ";", "d", ".", "vmode", "=", "GET_MODE", "(", "d", ".", "target", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "false", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "rtx", "e", "=", "XVECEXP", "(", "sel", ",", "0", ",", "i", ")", ";", "int", "ei", "=", "INTVAL", "(", "e", ")", "&", "(", "2", "*", "nelt", "-", "1", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "1", ":", "2", ")", ";", "orig_perm", "[", "i", "]", "=", "ei", ";", "}", "memcpy", "(", "d", ".", "perm", ",", "orig_perm", ",", "MAX_VECT_LEN", ")", ";", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "d", ".", "one_vector_p", "=", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "d", ".", "op0", ",", "d", ".", "op1", ")", ")", "break", ";", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "&=", "nelt", "-", "1", ";", "d", ".", "op0", "=", "d", ".", "op1", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "case", "1", ":", "d", ".", "op1", "=", "d", ".", "op0", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "}", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "if", "(", "!", "ok", "&&", "which", "==", "3", ")", "{", "d", ".", "op0", "=", "operands", "[", "1", "]", ";", "d", ".", "op1", "=", "operands", "[", "2", "]", ";", "d", ".", "one_vector_p", "=", "false", ";", "memcpy", "(", "d", ".", "perm", ",", "orig_perm", ",", "MAX_VECT_LEN", ")", ";", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "}", "return", "ok", ";", "}", "</s>" ]

[ "Expand", "a", "vec_perm_const", "pattern", "." ]

[ "mips", "4", "0", "1", "2", "3", "0", "0", "2", "1", "1", "2", "3", "2", "0", "1", "1", "3", "1", "2" ]

[]

[ "<s>", "bool", "A15SDOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "(", "STI", ".", "isCortexA15", "(", ")", "&&", "STI", ".", "hasNEON", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running on function \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DeadInstr", ".", "clear", "(", ")", ";", "Replacements", ".", "clear", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "MFI", "->", "begin", "(", ")", ",", "ME", "=", "MFI", "->", "end", "(", ")", ";", "MI", "!=", "ME", ";", ")", "{", "Modified", "|=", "runOnInstruction", "(", "&", "*", "MI", "++", ")", ";", "}", "}", "for", "(", "std", "::", "set", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "DeadInstr", ".", "begin", "(", ")", ",", "E", "=", "DeadInstr", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "(", "*", "I", ")", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "ARM", "ARM", "ARM", "\"Running on function \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "STI", "=", "&", "static_cast", "<", "const", "M680x0Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "MOVEMState", "State", ";", "unsigned", "Mask", "=", "0", ";", "unsigned", "Reg", "=", "0", ";", "int", "Offset", "=", "0", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MI", "!=", "E", ")", "{", "auto", "NMI", "=", "std", "::", "next", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "State", ".", "HasBase", "(", ")", ")", "{", "State", ".", "SetEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "Modified", "=", "true", ";", "}", "break", ";", "case", "M680x0", "::", "MOVM32jm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "0", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32pm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32mj", ":", "Mask", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "0", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32mp", ":", "Mask", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "}", "MI", "=", "NMI", ";", "}", "if", "(", "State", ".", "HasBase", "(", ")", ")", "{", "State", ".", "SetEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "M680x0", "M680x0", "M680x0", "0", "0", "0", "M680x0::MOVM32jm", "1", "0", "0", "M680x0::MOVM32pm", "2", "1", "0", "M680x0::MOVM32mj", "0", "1", "0", "M680x0::MOVM32mp", "0", "2", "1" ]

[]

[ "<s>", "AVR", "::", "Fixups", "AVRMCExpr", "::", "getFixupKind", "(", ")", "const", "{", "AVR", "::", "Fixups", "Kind", "=", "AVR", "::", "Fixups", "::", "LastTargetFixupKind", ";", "switch", "(", "getKind", "(", ")", ")", "{", "case", "VK_AVR_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_lo8_ldi_neg", ":", "AVR", "::", "fixup_lo8_ldi", ";", "break", ";", "case", "VK_AVR_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_hi8_ldi_neg", ":", "AVR", "::", "fixup_hi8_ldi", ";", "break", ";", "case", "VK_AVR_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_hh8_ldi_neg", ":", "AVR", "::", "fixup_hh8_ldi", ";", "break", ";", "case", "VK_AVR_HHI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_ms8_ldi_neg", ":", "AVR", "::", "fixup_ms8_ldi", ";", "break", ";", "case", "VK_AVR_PM_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_lo8_ldi_pm_neg", ":", "AVR", "::", "fixup_lo8_ldi_pm", ";", "break", ";", "case", "VK_AVR_PM_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_hi8_ldi_pm_neg", ":", "AVR", "::", "fixup_hi8_ldi_pm", ";", "break", ";", "case", "VK_AVR_PM_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "AVR", "::", "fixup_hh8_ldi_pm_neg", ":", "AVR", "::", "fixup_hh8_ldi_pm", ";", "break", ";", "case", "VK_AVR_PM", ":", "case", "VK_AVR_GS", ":", "Kind", "=", "AVR", "::", "fixup_16_pm", ";", "break", ";", "case", "VK_AVR_LO8_GS", ":", "Kind", "=", "AVR", "::", "fixup_lo8_ldi_gs", ";", "break", ";", "case", "VK_AVR_HI8_GS", ":", "Kind", "=", "AVR", "::", "fixup_hi8_ldi_gs", ";", "break", ";", "case", "VK_AVR_None", ":", "llvm_unreachable", "(", "\"Uninitialized expression\"", ")", ";", "}", "return", "Kind", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "AVR", "AVR::Fixups", "AVR", "AVR::Fixups", "AVR::Fixups", "AVR", "AVR::fixup_lo8_ldi_neg", "AVR::fixup_lo8_ldi", "AVR", "AVR::fixup_hi8_ldi_neg", "AVR::fixup_hi8_ldi", "AVR", "AVR::fixup_hh8_ldi_neg", "AVR::fixup_hh8_ldi", "AVR", "AVR::fixup_ms8_ldi_neg", "AVR::fixup_ms8_ldi", "AVR", "AVR::fixup_lo8_ldi_pm_neg", "AVR::fixup_lo8_ldi_pm", "AVR", "AVR::fixup_hi8_ldi_pm_neg", "AVR::fixup_hi8_ldi_pm", "AVR", "AVR::fixup_hh8_ldi_pm_neg", "AVR::fixup_hh8_ldi_pm", "AVR", "AVR", "AVR::fixup_16_pm", "AVR", "AVR::fixup_lo8_ldi_gs", "AVR", "AVR::fixup_hi8_ldi_gs", "AVR", "\"Uninitialized expression\"" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHU", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "false", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRem", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRemU", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "lowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "lowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "MipsTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Mips", "Mips", "ISD::LOAD", "ISD::STORE", "ISD::SMUL_LOHI", "MipsISD::Mult", "ISD::UMUL_LOHI", "MipsISD::Multu", "ISD::MULHS", "MipsISD::Mult", "ISD::MULHU", "MipsISD::Multu", "ISD::MUL", "MipsISD::Mult", "ISD::SDIVREM", "MipsISD::DivRem", "ISD::UDIVREM", "MipsISD::DivRemU", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "Mips" ]

[]

[ "<s>", "static", "void", "get_pc_thunk_name", "(", "char", "name", "[", "32", "]", ",", "unsigned", "int", "regno", ")", "{", "const", "char", "*", "reg_name", "=", "reg_names", "[", "regno", "]", ";", "reg_name", "+=", "1", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "sprintf", "(", "name", ",", "\"__sparc_get_pc_thunk.%s\"", ",", "reg_name", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LADDPC\"", ",", "regno", ")", ";", "}", "</s>" ]

[ "Fills", "in", "the", "label", "name", "that", "should", "be", "used", "for", "a", "pc", "thunk", "for", "the", "given", "register", "." ]

[ "sparc", "32", "1", "\"__sparc_get_pc_thunk.%s\"", "\"LADDPC\"" ]

[]

[ "<s>", "bool", "Cpu0AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "if", "(", "Mnemonic", "==", "\"ret\"", ")", "Mnemonic", "=", "\"jr\"", ";", "Operands", ".", "push_back", "(", "Cpu0Operand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "Cpu0", "Cpu0", "0", "\"ret\"", "\"jr\"", "Cpu0Operand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "int", "memory_address_length", "(", "rtx", "addr", ",", "bool", "lea", ")", "{", "struct", "ix86_address", "parts", ";", "rtx", "base", ",", "index", ",", "disp", ";", "int", "len", ";", "int", "ok", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "return", "0", ";", "ok", "=", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", ";", "gcc_assert", "(", "ok", ")", ";", "len", "=", "(", "parts", ".", "seg", "==", "ADDR_SPACE_GENERIC", ")", "?", "0", ":", "1", ";", "if", "(", "TARGET_64BIT", "&&", "!", "lea", "&&", "(", "SImode_address_operand", "(", "addr", ",", "VOIDmode", ")", "||", "(", "parts", ".", "base", "&&", "GET_MODE", "(", "parts", ".", "base", ")", "==", "SImode", ")", "||", "(", "parts", ".", "index", "&&", "GET_MODE", "(", "parts", ".", "index", ")", "==", "SImode", ")", ")", ")", "len", "++", ";", "base", "=", "parts", ".", "base", ";", "index", "=", "parts", ".", "index", ";", "disp", "=", "parts", ".", "disp", ";", "if", "(", "base", "&&", "SUBREG_P", "(", "base", ")", ")", "base", "=", "SUBREG_REG", "(", "base", ")", ";", "if", "(", "index", "&&", "SUBREG_P", "(", "index", ")", ")", "index", "=", "SUBREG_REG", "(", "index", ")", ";", "gcc_assert", "(", "base", "==", "NULL_RTX", "||", "REG_P", "(", "base", ")", ")", ";", "gcc_assert", "(", "index", "==", "NULL_RTX", "||", "REG_P", "(", "index", ")", ")", ";", "if", "(", "base", "&&", "!", "index", "&&", "!", "disp", ")", "{", "if", "(", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", "len", "++", ";", "}", "else", "if", "(", "disp", "&&", "!", "base", "&&", "!", "index", ")", "{", "len", "+=", "4", ";", "if", "(", "!", "rip_relative_addr_p", "(", "&", "parts", ")", ")", "len", "++", ";", "}", "else", "{", "if", "(", "disp", ")", "{", "if", "(", "base", "&&", "satisfies_constraint_K", "(", "disp", ")", ")", "len", "+=", "1", ";", "else", "len", "+=", "4", ";", "}", "else", "if", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "BP_REG", "||", "REGNO", "(", "base", ")", "==", "R13_REG", ")", ")", "len", "++", ";", "if", "(", "index", "||", "base", "==", "arg_pointer_rtx", "||", "base", "==", "frame_pointer_rtx", "||", "(", "base", "&&", "(", "REGNO", "(", "base", ")", "==", "SP_REG", "||", "REGNO", "(", "base", ")", "==", "R12_REG", ")", ")", ")", "len", "++", ";", "}", "return", "len", ";", "}", "</s>" ]

[ "Calculate", "the", "length", "of", "the", "memory", "address", "in", "the", "instruction", "encoding", ".", "Does", "not", "include", "the", "one-byte", "modrm", ",", "opcode", ",", "or", "prefix", "." ]

[ "i386", "0", "0", "1", "4", "1", "4" ]

[]

[ "<s>", "static", "bool", "originalTypeIsVectorFloat", "(", "const", "Type", "*", "Ty", ")", "{", "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "Ty", "->", "isFPOrFPVectorTy", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "original", "type", "was", "vXfXX", "/", "vXfXX", "." ]

[ "Mips" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitInlineAsmStart", "(", "const", "MCSubtargetInfo", "&", "StartInfo", ")", "const", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "emitDirectiveSetPush", "(", ")", ";", "TS", ".", "emitDirectiveSetAt", "(", ")", ";", "TS", ".", "emitDirectiveSetMacro", "(", ")", ";", "TS", ".", "emitDirectiveSetReorder", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "before", "emitting", "inlineasm", "." ]

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "ix86_save_reg", "(", "unsigned", "int", "regno", ",", "bool", "maybe_eh_return", ",", "bool", "ignore_outlined", ")", "{", "if", "(", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "{", "rtx", "reg", "=", "crtl", "->", "return_rtx", ";", "if", "(", "reg", ")", "{", "unsigned", "int", "i", "=", "REGNO", "(", "reg", ")", ";", "unsigned", "int", "nregs", "=", "REG_NREGS", "(", "reg", ")", ";", "while", "(", "nregs", "--", ">", "0", ")", "if", "(", "(", "i", "+", "nregs", ")", "==", "regno", ")", "return", "false", ";", "}", "return", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "STACK_REGNO_P", "(", "regno", ")", "&&", "!", "MMX_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ")", ";", "}", "if", "(", "regno", "==", "REAL_PIC_OFFSET_TABLE_REGNUM", "&&", "pic_offset_table_rtx", ")", "{", "if", "(", "ix86_use_pseudo_pic_reg", "(", ")", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "crtl", "->", "profile", ")", "return", "true", ";", "}", "else", "if", "(", "df_regs_ever_live_p", "(", "REAL_PIC_OFFSET_TABLE_REGNUM", ")", "||", "crtl", "->", "profile", "||", "crtl", "->", "calls_eh_return", "||", "crtl", "->", "uses_const_pool", "||", "cfun", "->", "has_nonlocal_label", ")", "return", "ix86_select_alt_pic_regnum", "(", ")", "==", "INVALID_REGNUM", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", "&&", "maybe_eh_return", ")", "{", "unsigned", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "unsigned", "test", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "return", "true", ";", "}", "}", "if", "(", "ignore_outlined", "&&", "cfun", "->", "machine", "->", "call_ms2sysv", ")", "{", "unsigned", "count", "=", "cfun", "->", "machine", "->", "call_ms2sysv_extra_regs", "+", "xlogue_layout", "::", "MIN_REGS", ";", "if", "(", "xlogue_layout", "::", "is_stub_managed_reg", "(", "regno", ",", "count", ")", ")", "return", "false", ";", "}", "if", "(", "crtl", "->", "drap_reg", "&&", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", "&&", "!", "cfun", "->", "machine", "->", "no_drap_save_restore", ")", "return", "true", ";", "return", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "we", "need", "to", "save", "REGNO", "." ]

[ "i386", "0", "0" ]

[]

[ "<s>", "static", "unsigned", "rs6000_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "rs6000_cost_data", "*", "cost_data", "=", "(", "rs6000_cost_data", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "rs6000_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "stmt_cost", "+=", "adjust_vectorization_cost", "(", "kind", ",", "stmt_info", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost_data", "->", "cost", "[", "where", "]", "+=", "retval", ";", "if", "(", "(", "kind", "==", "vec_to_scalar", "||", "kind", "==", "vec_perm", "||", "kind", "==", "vec_promote_demote", "||", "kind", "==", "vec_construct", "||", "kind", "==", "scalar_to_vec", ")", "||", "(", "where", "==", "vect_body", "&&", "kind", "==", "vector_stmt", ")", ")", "rs6000_vect_nonmem", "=", "true", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "rs6000", "0", "50" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", ".", "isZero", "(", ")", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "StackOffset", "=", "Handler", ".", "StackUsed", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "Subtarget", ".", "isTargetILP32", "(", ")", "?", "4", ":", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "if", "(", "doesCalleeRestoreStack", "(", "F", ".", "getCallingConv", "(", ")", ",", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ")", "{", "StackOffset", "=", "alignTo", "(", "StackOffset", ",", "16", ")", ";", "FuncInfo", "->", "setArgumentStackToRestore", "(", "StackOffset", ")", ";", "}", "FuncInfo", "->", "setBytesInStackArgArea", "(", "StackOffset", ")", ";", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasCustomCallingConv", "(", ")", ")", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "UpdateCustomCalleeSavedRegs", "(", "MF", ")", ";", "handleMustTailForwardedRegisters", "(", "MIRBuilder", ",", "AssignFn", ")", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "8", "0", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "4", "8", "4", "16", "AArch64" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForStrcmp", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Src1", ".", "getValueType", "(", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Unused", "=", "DAG", ".", "getNode", "(", "SystemZISD", "::", "STRCMP", ",", "DL", ",", "VTs", ",", "Chain", ",", "Src2", ",", "Src1", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "CCReg", "=", "Unused", ".", "getValue", "(", "1", ")", ";", "Chain", "=", "Unused", ".", "getValue", "(", "2", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "CCReg", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "strcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "MVT::i32", "MVT::Other", "SystemZISD::STRCMP", "0", "MVT::i32", "1", "2" ]

[]

[ "<s>", "void", "MipsOutgoingValueHandler", "::", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "{", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_floatn_mode", "(", "int", "n", ",", "bool", "extended", ")", "{", "if", "(", "extended", ")", "{", "switch", "(", "n", ")", "{", "case", "32", ":", "return", "DFmode", ";", "case", "64", ":", "if", "(", "TARGET_FLOAT128_KEYWORD", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "else", "return", "VOIDmode", ";", "case", "128", ":", "return", "VOIDmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "n", ")", "{", "case", "32", ":", "return", "SFmode", ";", "case", "64", ":", "return", "DFmode", ";", "case", "128", ":", "if", "(", "TARGET_FLOAT128_KEYWORD", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "else", "return", "VOIDmode", ";", "default", ":", "return", "VOIDmode", ";", "}", "}", "}", "</s>" ]

[ "Target", "hook", "for", "floatn_mode", "." ]

[ "rs6000", "32", "64", "128", "32", "64", "128" ]

[]

[ "<s>", "bool", "DLXInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "TargetPassConfig", "*", "HexagonTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "HexagonPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "HasAlloca", "=", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "bool", "NeedsAlign", "=", "(", "MFI", "->", "getMaxAlignment", "(", ")", ">", "getStackAlignment", "(", ")", ")", ";", "if", "(", "!", "HasAlloca", "||", "!", "NeedsAlign", ")", "return", ";", "unsigned", "LFS", "=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MFI", "->", "isSpillSlotObjectIndex", "(", "i", ")", "||", "MFI", "->", "isDeadObjectIndex", "(", "i", ")", ")", "continue", ";", "unsigned", "S", "=", "MFI", "->", "getObjectSize", "(", "i", ")", ";", "unsigned", "A", "=", "std", "::", "max", "(", "MFI", "->", "getObjectAlignment", "(", "i", ")", ",", "8U", ")", ";", "MFI", "->", "setObjectAlignment", "(", "i", ",", "8", ")", ";", "LFS", "=", "alignTo", "(", "LFS", "+", "S", ",", "A", ")", ";", "MFI", "->", "mapLocalFrameObject", "(", "i", ",", "-", "LFS", ")", ";", "}", "MFI", "->", "setLocalFrameSize", "(", "LFS", ")", ";", "unsigned", "A", "=", "MFI", "->", "getLocalFrameMaxAlign", "(", ")", ";", "assert", "(", "A", "<=", "8", "&&", "\"Unexpected local frame alignment\"", ")", ";", "if", "(", "A", "==", "0", ")", "MFI", "->", "setLocalFrameMaxAlign", "(", "8", ")", ";", "MFI", "->", "setUseLocalStackAllocationBlock", "(", "true", ")", ";", "unsigned", "AP", "=", "0", ";", "if", "(", "const", "MachineInstr", "*", "AI", "=", "getAlignaInstr", "(", "MF", ")", ")", "AP", "=", "AI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "HMFI", ".", "setStackAlignBasePhysReg", "(", "AP", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Hexagon", "Hexagon", "0", "8U", "8", "8", "\"Unexpected local frame alignment\"", "0", "8", "0", "0", "Hexagon" ]

[]

[ "<s>", "const", "LatticeCell", "&", "get", "(", "unsigned", "R", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "R", ")", ")", "return", "Bottom", ";", "MapType", "::", "const_iterator", "F", "=", "Map", ".", "find", "(", "R", ")", ";", "if", "(", "F", "!=", "Map", ".", "end", "(", ")", ")", "return", "F", "->", "second", ";", "return", "Top", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "Hexagon" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "IsO32", ",", "Subtarget", "->", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", "->", "mipsSEUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "IsN64", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other", "0" ]

[]

[ "<s>", "static", "bool", "aarch_macro_fusion_pair_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "curr", ")", "{", "rtx", "prev_set", "=", "single_set", "(", "prev", ")", ";", "rtx", "curr_set", "=", "single_set", "(", "curr", ")", ";", "if", "(", "!", "prev_set", "||", "!", "curr_set", ")", "return", "false", ";", "if", "(", "any_condjump_p", "(", "curr", ")", ")", "return", "false", ";", "if", "(", "!", "arm_macro_fusion_p", "(", ")", ")", "return", "false", ";", "if", "(", "current_tune", "->", "fusible_ops", "&", "tune_params", "::", "FUSE_AES_AESMC", "&&", "aarch_crypto_can_dual_issue", "(", "prev", ",", "curr", ")", ")", "return", "true", ";", "if", "(", "current_tune", "->", "fusible_ops", "&", "tune_params", "::", "FUSE_MOVW_MOVT", "&&", "arm_sets_movw_movt_fusible_p", "(", "prev_set", ",", "curr_set", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_PAIR_P", ".", "Return", "true", "if", "PREV", "and", "CURR", "should", "be", "kept", "together", "during", "scheduling", "." ]

[ "arm" ]

[]

[ "<s>", "const", "std", "::", "string", "&", "getName", "(", ")", "const", "{", "return", "Name", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "PIC16" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getPICCallReg", "(", "void", ")", "{", "return", "Mips", "::", "T9", ";", "}", "</s>" ]

[ "Get", "PIC", "indirect", "call", "register", "." ]

[ "Mips", "Mips", "Mips::T9" ]

[]

[ "<s>", "const", "SpillSlot", "*", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "override", "{", "static", "const", "SpillSlot", "Offsets", "[", "]", "=", "{", "{", "Hexagon", "::", "R17", ",", "-", "4", "}", ",", "{", "Hexagon", "::", "R16", ",", "-", "8", "}", ",", "{", "Hexagon", "::", "D8", ",", "-", "8", "}", ",", "{", "Hexagon", "::", "R19", ",", "-", "12", "}", ",", "{", "Hexagon", "::", "R18", ",", "-", "16", "}", ",", "{", "Hexagon", "::", "D9", ",", "-", "16", "}", ",", "{", "Hexagon", "::", "R21", ",", "-", "20", "}", ",", "{", "Hexagon", "::", "R20", ",", "-", "24", "}", ",", "{", "Hexagon", "::", "D10", ",", "-", "24", "}", ",", "{", "Hexagon", "::", "R23", ",", "-", "28", "}", ",", "{", "Hexagon", "::", "R22", ",", "-", "32", "}", ",", "{", "Hexagon", "::", "D11", ",", "-", "32", "}", ",", "{", "Hexagon", "::", "R25", ",", "-", "36", "}", ",", "{", "Hexagon", "::", "R24", ",", "-", "40", "}", ",", "{", "Hexagon", "::", "D12", ",", "-", "40", "}", ",", "{", "Hexagon", "::", "R27", ",", "-", "44", ",", "{", "Hexagon", "::", "R26", ",", "-", "48", ",", "{", "Hexagon", "::", "D13", ",", "-", "48", "}", "}", ";", "NumEntries", "=", "array_lengthof", "(", "Offsets", ")", ";", "return", "Offsets", ";", "}", "bool", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "override", ";", "bool", "needsAligna", "(", "const", "MachineFunction", "&", "MF", ")", "const", ";", "MachineInstr", "*", "getAlignaInstr", "(", "MachineFunction", "&", "MF", ")", "const", ";", "private", ":", "typedef", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "CSIVect", ";", "void", "expandAlloca", "(", "MachineInstr", "*", "AI", ",", "const", "HexagonInstrInfo", "&", "TII", ",", "unsigned", "SP", ",", "unsigned", "CF", ")", "const", ";", "void", "insertPrologueInBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "const", ";", "void", "insertEpilogueInBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "const", ";", "bool", "insertCSRSpillsInBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "const", "CSIVect", "&", "CSI", ",", "const", "HexagonRegisterInfo", "&", "HRI", ")", "const", ";", "bool", "insertCSRRestoresInBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "const", "CSIVect", "&", "CSI", ",", "const", "HexagonRegisterInfo", "&", "HRI", ")", "const", ";", "void", "adjustForCalleeSavedRegsSpillCall", "(", "MachineFunction", "&", "MF", ")", "const", ";", "bool", "replacePredRegPseudoSpillCode", "(", "MachineFunction", "&", "MF", ")", "const", ";", "bool", "replaceVecPredRegPseudoSpillCode", "(", "MachineFunction", "&", "MF", ")", "const", ";", "void", "findShrunkPrologEpilog", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "*", "&", "PrologB", ",", "MachineBasicBlock", "*", "&", "EpilogB", ")", "const", ";", "bool", "shouldInlineCSR", "(", "llvm", "::", "MachineFunction", "&", ",", "const", "CSIVect", "&", ")", "const", ";", "bool", "useSpillFunction", "(", "MachineFunction", "&", "MF", ",", "const", "CSIVect", "&", "CSI", ")", "const", ";", "bool", "useRestoreFunction", "(", "MachineFunction", "&", "MF", ",", "const", "CSIVect", "&", "CSI", ")", "const", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "Hexagon", "Hexagon::R17", "4", "Hexagon::R16", "8", "Hexagon::D8", "8", "Hexagon::R19", "12", "Hexagon::R18", "16", "Hexagon::D9", "16", "Hexagon::R21", "20", "Hexagon::R20", "24", "Hexagon::D10", "24", "Hexagon::R23", "28", "Hexagon::R22", "32", "Hexagon::D11", "32", "Hexagon::R25", "36", "Hexagon::R24", "40", "Hexagon::D12", "40", "Hexagon::R27", "44", "Hexagon::R26", "48", "Hexagon::D13", "48", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARC Branch Finalization Pass\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARC", "\"ARC Branch Finalization Pass\"" ]

[]

[ "<s>", "rtx", "loongarch_emit_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "return", "(", "can_create_pseudo_p", "(", ")", "?", "emit_move_insn", "(", "dest", ",", "src", ")", ":", "emit_move_insn_1", "(", "dest", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "move", "expanders", "can", "handle", "all", "moves", "if", "!", "can_create_pseudo_p", "(", ")", ".", "The", "distinction", "is", "important", "because", ",", "unlike", "emit_move_insn", ",", "the", "move", "expanders", "know", "how", "to", "force", "Pmode", "objects", "into", "the", "constant", "pool", "even", "when", "the", "constant", "pool", "address", "is", "not", "itself", "legitimate", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "HexagonGenInsert", "::", "removeDeadCode", "(", "MachineDomTreeNode", "*", "N", ")", "{", "bool", "Changed", "=", "false", ";", "typedef", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", "GTN", ";", "for", "(", "auto", "I", "=", "GTN", "::", "child_begin", "(", "N", ")", ",", "E", "=", "GTN", "::", "child_end", "(", "N", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Changed", "|=", "removeDeadCode", "(", "*", "I", ")", ";", "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "auto", "I", "=", "B", "->", "rbegin", "(", ")", ",", "E", "=", "B", "->", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Instrs", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "auto", "I", "=", "Instrs", ".", "begin", "(", ")", ",", "E", "=", "Instrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Regs", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "R", ")", "||", "!", "MRI", "->", "use_nodbg_empty", "(", "R", ")", ")", "{", "AllDead", "=", "false", ";", "break", ";", "}", "Regs", ".", "push_back", "(", "R", ")", ";", "}", "if", "(", "!", "AllDead", ")", "continue", ";", "B", "->", "erase", "(", "MI", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "N", "=", "Regs", ".", "size", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "MRI", "->", "markUsesInDebugValueAsUndef", "(", "Regs", "[", "I", "]", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "2", "0" ]

[]

[ "<s>", "static", "int", "ix86_fp_cmp_code_to_pcmp_immediate", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "0x00", ";", "case", "NE", ":", "return", "0x04", ";", "case", "GT", ":", "return", "0x0e", ";", "case", "LE", ":", "return", "0x02", ";", "case", "GE", ":", "return", "0x0d", ";", "case", "LT", ":", "return", "0x01", ";", "case", "UNLE", ":", "return", "0x0a", ";", "case", "UNLT", ":", "return", "0x09", ";", "case", "UNGE", ":", "return", "0x05", ";", "case", "UNGT", ":", "return", "0x06", ";", "case", "UNEQ", ":", "return", "0x18", ";", "case", "LTGT", ":", "return", "0x0c", ";", "case", "ORDERED", ":", "return", "0x07", ";", "case", "UNORDERED", ":", "return", "0x03", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Helper", "for", "ix86_cmp_code_to_pcmp_immediate", "for", "fp", "modes", "." ]

[ "i386", "0x00", "0x04", "0x0e", "0x02", "0x0d", "0x01", "0x0a", "0x09", "0x05", "0x06", "0x18", "0x0c", "0x07", "0x03" ]

[]

[ "<s>", "static", "void", "process_cfa_adjust_cfa", "(", "FILE", "*", "asm_out_file", ",", "rtx", "pat", ",", "rtx", "insn", ",", "bool", "unwind", ",", "bool", "frame", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "dest", "==", "stack_pointer_rtx", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "gcc_assert", "(", "op0", "==", "dest", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", ";", "if", "(", "INTVAL", "(", "op1", ")", "<", "0", ")", "{", "gcc_assert", "(", "!", "frame_pointer_needed", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.fframe \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "-", "INTVAL", "(", "op1", ")", ")", ";", "}", "else", "process_epilogue", "(", "asm_out_file", ",", "insn", ",", "unwind", ",", "frame", ")", ";", "}", "else", "{", "gcc_assert", "(", "src", "==", "hard_frame_pointer_rtx", ")", ";", "process_epilogue", "(", "asm_out_file", ",", "insn", ",", "unwind", ",", "frame", ")", ";", "}", "}", "else", "if", "(", "dest", "==", "hard_frame_pointer_rtx", ")", "{", "gcc_assert", "(", "src", "==", "stack_pointer_rtx", ")", ";", "gcc_assert", "(", "frame_pointer_needed", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.vframe r%d\\n\"", ",", "ia64_dbx_register_number", "(", "REGNO", "(", "dest", ")", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "processes", "a", "SET", "pattern", "for", "REG_CFA_ADJUST_CFA", "." ]

[ "ia64", "0", "1", "0", "\"\\t.fframe \"", "\"\\n\"", "\"\\t.vframe r%d\\n\"" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "CurArgInfo", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VRegs", "[", "i", "]", ")", ";", "}", ")", ")", "return", "false", ";", "}", "X86OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "X86", "X86", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "0", "X86", "X86" ]

[]

[ "<s>", "static", "tree", "sh2a_handle_function_vector_handler_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "!", "TARGET_SH2A", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to SH2A\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute argument not an integer constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "args", ")", ")", ">", "255", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute argument should be between 0 to 255\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "'function_vector", "'", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qE attribute only applies to SH2A\"", "\"%qE attribute only applies to functions\"", "\"%qE attribute argument not an integer constant\"", "255", "\"%qE attribute argument should be between 0 to 255\"" ]

[]

[ "<s>", "bool", "SPUPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createSPUISelDag", "(", "getSPUTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "CellSPU", "SPU", "SPU", "SPU" ]

[]

[ "<s>", "tree", "ix86_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "enum", "ix86_builtins", "fn_code", "=", "(", "enum", "ix86_builtins", ")", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "switch", "(", "fn_code", ")", "{", "case", "IX86_BUILTIN_SQRTPS_NR", ":", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_RSQRTPS_NR", ")", ";", "case", "IX86_BUILTIN_SQRTPS_NR256", ":", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_RSQRTPS_NR256", ")", ";", "default", ":", "return", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Returns", "a", "code", "for", "a", "target-specific", "builtin", "that", "implements", "reciprocal", "of", "the", "function", ",", "or", "NULL_TREE", "if", "not", "available", "." ]

[ "i386" ]

[]

[ "<s>", "DFAPacketizer", "*", "R600InstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetSubtargetInfo", "&", "STI", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "STI", ".", "getInstrItineraryData", "(", ")", ";", "return", "static_cast", "<", "const", "AMDGPUSubtarget", "&", ">", "(", "STI", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "vax_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "function", ")", "{", "fprintf", "(", "file", ",", "\"\\t.word 0x0ffc\\n\\taddl2 $\"", "HOST_WIDE_INT_PRINT_DEC", ",", "delta", ")", ";", "asm_fprintf", "(", "file", ",", "\",4(%Rap)\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tjmp \"", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+2\\n\"", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", ".", ".mask", "^m", "<", "r2", ",", "r3", ",", "r4", ",", "r5", ",", "r6", ",", "r7", ",", "r8", ",", "r9", ",", "r10", ",", "r11", ">", "#", "conservative", "entry", "mask", "addl2", "$", "DELTA", ",", "4", "(", "ap", ")", "#", "adjust", "first", "argument", "jmp", "FUNCTION+2", "#", "jump", "beyond", "FUNCTION", "'s", "entry", "mask" ]

[ "vax", "\"\\t.word 0x0ffc\\n\\taddl2 $\"", "\",4(%Rap)\\n\"", "\"\\tjmp \"", "0", "0", "\"+2\\n\"" ]

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "bool", "Result", "=", "PPCAsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "auto", "setCsectAlignment", "=", "[", "this", "]", "(", "const", "GlobalObject", "*", "GO", ")", "{", "if", "(", "GO", "->", "isDeclarationForLinker", "(", ")", ")", "return", ";", "SectionKind", "GOKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GO", ",", "TM", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GO", ",", "GOKind", ",", "TM", ")", ")", ";", "Align", "GOAlign", "=", "getGVAlignment", "(", "GO", ",", "GO", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "if", "(", "GOAlign", ">", "Csect", "->", "getAlignment", "(", ")", ")", "Csect", "->", "setAlignment", "(", "GOAlign", ")", ";", "}", ";", "for", "(", "const", "auto", "&", "G", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "&", "G", ")", ")", "continue", ";", "if", "(", "isSpecialLLVMGlobalArrayForStaticInit", "(", "&", "G", ")", ")", "{", "if", "(", "FormatIndicatorAndUniqueModId", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "UniqueModuleId", "=", "getUniqueModuleId", "(", "&", "M", ")", ";", "if", "(", "UniqueModuleId", "!=", "\"\"", ")", "FormatIndicatorAndUniqueModId", "=", "\"clang_\"", "+", "UniqueModuleId", ".", "substr", "(", "1", ")", ";", "else", "FormatIndicatorAndUniqueModId", "=", "\"clangPidTime_\"", "+", "llvm", "::", "itostr", "(", "sys", "::", "Process", "::", "getProcessId", "(", ")", ")", "+", "\"_\"", "+", "llvm", "::", "itostr", "(", "time", "(", "nullptr", ")", ")", ";", "}", "emitSpecialLLVMGlobal", "(", "&", "G", ")", ";", "continue", ";", "}", "setCsectAlignment", "(", "&", "G", ")", ";", "}", "for", "(", "const", "auto", "&", "F", ":", "M", ")", "setCsectAlignment", "(", "&", "F", ")", ";", "for", "(", "const", "auto", "&", "Alias", ":", "M", ".", "aliases", "(", ")", ")", "{", "const", "GlobalObject", "*", "Base", "=", "Alias", ".", "getBaseObject", "(", ")", ";", "if", "(", "!", "Base", ")", "report_fatal_error", "(", "\"alias without a base object is not yet supported on AIX\"", ")", ";", "GOAliasMap", "[", "Base", "]", ".", "push_back", "(", "&", "Alias", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "PowerPC", "PPC", "PPC", "\"\"", "\"clang_\"", "1", "\"clangPidTime_\"", "\"_\"", "\"alias without a base object is not yet supported on AIX\"" ]

[]

[ "<s>", "MCELFStreamer", "&", "MipsTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "bool", "Found", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "bool", "ClobbersCPSR", "=", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "CPSR", ")", ";", "bool", "IsCPSR", "=", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ";", "if", "(", "ClobbersCPSR", "||", "IsCPSR", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", "&&", "MO", ".", "isDead", "(", ")", "&&", "SkipDead", ")", "continue", ";", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "return", "Found", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "ARM", "ARM", "0", "ARM::CPSR", "ARM::CPSR", "ARMII::ThumbArithFlagSetting" ]

[]

[ "<s>", "bool", "pa_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_64BIT", "?", "16", ":", "8", ")", "||", "int_size_in_bytes", "(", "type", ")", "<=", "0", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "pa", "16", "8", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "ix86_mangle_fundamental_type", "(", "tree", "type", ")", "{", "switch", "(", "TYPE_MODE", "(", "type", ")", ")", "{", "case", "TFmode", ":", "return", "\"g\"", ";", "case", "XFmode", ":", "return", "\"e\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

[ "Return", "the", "mangling", "of", "TYPE", "if", "it", "is", "an", "extended", "fundamental", "type", "." ]

[ "i386", "\"g\"", "\"e\"" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Z80" ]

[]

[ "<s>", "const", "MMIXInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "MMIX", "MMIX" ]

[]

[ "<s>", "void", "MipsGOT", "::", "split", "(", ")", "{", "m_MergedLocalSymbols", ".", "clear", "(", ")", ";", "m_MergedGlobalSymbols", ".", "clear", "(", ")", ";", "size_t", "uniqueCount", "=", "0", ";", "for", "(", "SymbolUniqueMapType", "::", "const_iterator", "it", "=", "m_InputGlobalSymbols", ".", "begin", "(", ")", ",", "end", "=", "m_InputGlobalSymbols", ".", "end", "(", ")", ";", "it", "!=", "end", ";", "++", "it", ")", "{", "if", "(", "it", "->", "second", ")", "++", "uniqueCount", ";", "}", "m_MultipartList", ".", "back", "(", ")", ".", "m_LocalNum", "-=", "m_InputLocalSymbols", ".", "size", "(", ")", ";", "m_MultipartList", ".", "back", "(", ")", ".", "m_GlobalNum", "-=", "uniqueCount", ";", "m_MultipartList", ".", "back", "(", ")", ".", "m_Inputs", ".", "erase", "(", "m_pInput", ")", ";", "m_MultipartList", ".", "push_back", "(", "GOTMultipart", "(", "m_InputLocalSymbols", ".", "size", "(", ")", ",", "m_InputGlobalSymbols", ".", "size", "(", ")", ")", ")", ";", "m_MultipartList", ".", "back", "(", ")", ".", "m_Inputs", ".", "insert", "(", "m_pInput", ")", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Mips", "Mips", "0" ]

[]

[ "<s>", "int", "symbolic_operand", "(", "register", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "1", ";", "case", "CONST", ":", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "1", "if", "X", "contains", "a", "symbolic", "expression", ".", "We", "know", "these", "expressions", "will", "have", "one", "of", "a", "few", "well", "defined", "forms", ",", "so", "we", "need", "only", "check", "those", "forms", "." ]

[ "mn10300", "1", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "X86RetpolineThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "Is64Bit", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "Module", "&", "M", "=", "const_cast", "<", "Module", "&", ">", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "ThunkNamePrefix", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "(", "!", "STI", "->", "useRetpolineIndirectCalls", "(", ")", "&&", "!", "STI", "->", "useRetpolineIndirectBranches", "(", ")", ")", "||", "STI", "->", "useRetpolineExternalThunk", "(", ")", ")", "return", "false", ";", "if", "(", "Is64Bit", ")", "createThunkFunction", "(", "M", ",", "R11ThunkName", ")", ";", "else", "for", "(", "StringRef", "Name", ":", "{", "EAXThunkName", ",", "ECXThunkName", ",", "EDXThunkName", ",", "EDIThunkName", "}", ")", "createThunkFunction", "(", "M", ",", "Name", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "\"__llvm_retpoline_r11\"", "&&", "\"Should only have an r11 thunk on 64-bit targets\"", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDIThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDI", ")", ";", "else", "llvm_unreachable", "(", "\"Invalid thunk name on x86-32!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86", "X86", "\"__llvm_retpoline_r11\"", "\"Should only have an r11 thunk on 64-bit targets\"", "X86::R11", "X86::EAX", "X86::ECX", "X86::EDX", "X86::EDI", "\"Invalid thunk name on x86-32!\"" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "RelaxedOpcode", "=", "AMDGPU", "::", "getSOPPWithRelaxation", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "Res", ".", "setOpcode", "(", "RelaxedOpcode", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::getSOPPWithRelaxation", "0" ]

[]

[ "<s>", "static", "int", "thumb1_extra_regs_pushed", "(", "arm_stack_offsets", "*", "offsets", ",", "bool", "for_prologue", ")", "{", "HOST_WIDE_INT", "amount", ";", "unsigned", "long", "live_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "unsigned", "long", "l_mask", "=", "live_regs_mask", "&", "(", "for_prologue", "?", "0x40ff", ":", "0xff", ")", ";", "unsigned", "long", "high_regs_pushed", "=", "bit_count", "(", "live_regs_mask", "&", "0x0f00", ")", ";", "int", "n_free", ",", "reg_base", ",", "size", ";", "if", "(", "!", "for_prologue", "&&", "frame_pointer_needed", ")", "amount", "=", "offsets", "->", "locals_base", "-", "offsets", "->", "saved_regs", ";", "else", "amount", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "if", "(", "!", "optimize_size", "&&", "amount", "!=", "512", ")", "return", "0", ";", "if", "(", "high_regs_pushed", "!=", "0", ")", "return", "0", ";", "if", "(", "l_mask", "==", "0", "&&", "(", "for_prologue", "||", "TARGET_BACKTRACE", "||", "(", "live_regs_mask", "&", "1", "<<", "LR_REGNUM", ")", "==", "0", "||", "TARGET_INTERWORK", "||", "crtl", "->", "args", ".", "pretend_args_size", "!=", "0", ")", ")", "return", "0", ";", "if", "(", "for_prologue", "&&", "(", "(", "flag_pic", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", ")", "||", "(", "!", "frame_pointer_needed", "&&", "CALLER_INTERWORKING_SLOT_SIZE", ">", "0", ")", ")", ")", "return", "0", ";", "reg_base", "=", "0", ";", "n_free", "=", "0", ";", "if", "(", "!", "for_prologue", ")", "{", "size", "=", "arm_size_return_regs", "(", ")", ";", "reg_base", "=", "ARM_NUM_INTS", "(", "size", ")", ";", "live_regs_mask", ">>=", "reg_base", ";", "}", "while", "(", "reg_base", "+", "n_free", "<", "8", "&&", "!", "(", "live_regs_mask", "&", "1", ")", "&&", "(", "for_prologue", "||", "call_used_regs", "[", "reg_base", "+", "n_free", "]", ")", ")", "{", "live_regs_mask", ">>=", "1", ";", "n_free", "++", ";", "}", "if", "(", "n_free", "==", "0", ")", "return", "0", ";", "gcc_assert", "(", "amount", "/", "4", "*", "4", "==", "amount", ")", ";", "if", "(", "amount", ">=", "512", "&&", "(", "amount", "-", "n_free", "*", "4", ")", "<", "512", ")", "return", "(", "amount", "-", "508", ")", "/", "4", ";", "if", "(", "amount", "<=", "n_free", "*", "4", ")", "return", "amount", "/", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Given", "the", "stack", "offsets", "and", "register", "mask", "in", "OFFSETS", ",", "decide", "how", "many", "additional", "registers", "to", "push", "instead", "of", "subtracting", "a", "constant", "from", "SP", ".", "For", "epilogues", "the", "principle", "is", "the", "same", "except", "we", "use", "pop", ".", "FOR_PROLOGUE", "indicates", "which", "we", "'re", "generating", "." ]

[ "arm", "0x40ff", "0xff", "0x0f00", "512", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "8", "1", "1", "0", "0", "4", "4", "512", "4", "512", "508", "4", "4", "4", "0" ]

[]

[ "<s>", "static", "bool", "or1k_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", ",", "int", "*", "total", ",", "bool", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "x", "==", "const0_rtx", ")", "*", "total", "=", "0", ";", "else", "if", "(", "(", "outer_code", "==", "PLUS", "||", "outer_code", "==", "XOR", "||", "outer_code", "==", "MULT", ")", "&&", "satisfies_constraint_I", "(", "x", ")", ")", "*", "total", "=", "0", ";", "else", "if", "(", "(", "outer_code", "==", "AND", "||", "outer_code", "==", "IOR", ")", "&&", "satisfies_constraint_K", "(", "x", ")", ")", "*", "total", "=", "0", ";", "else", "if", "(", "satisfies_constraint_I", "(", "x", ")", "||", "satisfies_constraint_K", "(", "x", ")", "||", "satisfies_constraint_M", "(", "x", ")", ")", "*", "total", "=", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", "?", "0", ":", "COSTS_N_INSNS", "(", "2", ")", ")", ";", "return", "true", ";", "case", "HIGH", ":", "*", "total", "=", "2", ";", "return", "true", ";", "case", "LO_SUM", ":", "*", "total", "=", "(", "outer_code", "==", "MEM", "?", "0", ":", "2", ")", ";", "return", "true", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "if", "(", "outer_code", "==", "LO_SUM", "||", "outer_code", "==", "HIGH", ")", "*", "total", "=", "0", ";", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", "+", "(", "outer_code", "!=", "MEM", ")", ")", ";", "}", "return", "true", ";", "case", "PLUS", ":", "if", "(", "outer_code", "==", "MEM", ")", "*", "total", "=", "0", ";", "break", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_RTX_COSTS", "." ]

[ "or1k", "0", "0", "0", "2", "2", "0", "2", "2", "0", "2", "0", "1", "0" ]

[]

[ "<s>", "int", "fr30_check_multiple_regs", "(", "rtx", "*", "operands", ",", "int", "num_operands", ",", "int", "descending", ")", "{", "if", "(", "descending", ")", "{", "unsigned", "int", "prev_regno", "=", "0", ";", "while", "(", "num_operands", "--", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "num_operands", "]", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "operands", "[", "num_operands", "]", ")", "<", "prev_regno", ")", "return", "0", ";", "prev_regno", "=", "REGNO", "(", "operands", "[", "num_operands", "]", ")", ";", "}", "}", "else", "{", "unsigned", "int", "prev_regno", "=", "CONDITION_CODE_REGNUM", ";", "while", "(", "num_operands", "--", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "num_operands", "]", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "operands", "[", "num_operands", "]", ")", ">", "prev_regno", ")", "return", "0", ";", "prev_regno", "=", "REGNO", "(", "operands", "[", "num_operands", "]", ")", ";", "}", "}", "return", "1", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "all", "the", "registers", "in", "the", "operands", "array", "are", "in", "descending", "or", "ascending", "order", "." ]

[ "fr30", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "AnalyzeCallOperands", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "CCAssignFn", "Fn", ")", "{", "ArgIsFixed", ".", "clear", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Outs", ".", "size", "(", ")", ";", "++", "i", ")", "ArgIsFixed", ".", "push_back", "(", "Outs", "[", "i", "]", ".", "IsFixed", ")", ";", "ArgIsShortVector", ".", "clear", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Outs", ".", "size", "(", ")", ";", "++", "i", ")", "ArgIsShortVector", ".", "push_back", "(", "IsShortVectorType", "(", "Outs", "[", "i", "]", ".", "ArgVT", ")", ")", ";", "CCState", "::", "AnalyzeCallOperands", "(", "Outs", ",", "Fn", ")", ";", "}", "</s>" ]

[ "AnalyzeCallOperands", "-", "Same", "as", "above", "except", "it", "takes", "vectors", "of", "types", "and", "argument", "flags", "." ]

[ "SystemZ", "ISD::OutputArg", "0", "0" ]

[]

[ "<s>", "const", "PatmosTargetMachine", "&", "getTargetMachine", "(", ")", "const", "{", "return", "TM", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "Thumb2InstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "&", "II", ")", "const", "{", "return", "(", "ScheduleHazardRecognizer", "*", ")", "new", "Thumb2HazardRecognizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "useFastISel", "(", ")", "const", "{", "if", "(", "ForceFastISel", ")", "return", "true", ";", "if", "(", "!", "hasV6Ops", "(", ")", ")", "return", "false", ";", "return", "TM", ".", "Options", ".", "EnableFastISel", "&&", "(", "(", "isTargetMachO", "(", ")", "&&", "!", "isThumb1Only", "(", ")", ")", "||", "(", "isTargetLinux", "(", ")", "&&", "!", "isThumb", "(", ")", ")", "||", "(", "isTargetNaCl", "(", ")", "&&", "!", "isThumb", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "fast-isel", "is", "used", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ARCRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "ARC", "ARC" ]

[]

[ "<s>", "static", "bool", "nios2_simple_const_p", "(", "const_rtx", "cst", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "cst", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "cst", ")", ";", "return", "SMALL_INT", "(", "val", ")", "||", "SMALL_INT_UNSIGNED", "(", "val", ")", "||", "UPPER16_INT", "(", "val", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "CST", "is", "a", "constant", "within", "range", "of", "movi/movui/movhi", "." ]

[ "nios2" ]

[]

[ "<s>", "void", "BT", "::", "reset", "(", ")", "{", "EdgeExec", ".", "clear", "(", ")", ";", "InstrExec", ".", "clear", "(", ")", ";", "Map", ".", "clear", "(", ")", ";", "ReachedBB", ".", "clear", "(", ")", ";", "ReachedBB", ".", "reserve", "(", "MF", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon" ]

[]