Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "GCNDPPCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasDPP", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "llvm", "::", "reverse", "(", "MBB", ")", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MOV_B32_dpp", "&&", "combineDPPMov", "(", "MI", ")", ")", "{", "Changed", "=", "true", ";", "++", "NumDPPMovsCombined", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MOV_B64_DPP_PSEUDO", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MOV_B64_dpp", ")", "{", "if", "(", "ST", "->", "has64BitDPP", "(", ")", "&&", "combineDPPMov", "(", "MI", ")", ")", "{", "Changed", "=", "true", ";", "++", "NumDPPMovsCombined", ";", "}", "else", "{", "auto", "Split", "=", "TII", "->", "expandMovDPP64", "(", "MI", ")", ";", "for", "(", "auto", "M", ":", "{", "Split", ".", "first", ",", "Split", ".", "second", "}", ")", "{", "if", "(", "M", "&&", "combineDPPMov", "(", "*", "M", ")", ")", "++", "NumDPPMovsCombined", ";", "}", "Changed", "=", "true", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU::V_MOV_B32_dpp", "AMDGPU::V_MOV_B64_DPP_PSEUDO", "AMDGPU::V_MOV_B64_dpp" ]

[]

[ "<s>", "static", "void", "aarch64_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "R0_REGNUM", ";", "rtx", "this_rtx", ",", "temp0", ",", "temp1", ",", "addr", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "if", "(", "aarch64_bti_enabled", "(", ")", ")", "emit_insn", "(", "gen_bti_c", "(", ")", ")", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "EP0_REGNUM", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "EP1_REGNUM", ")", ";", "if", "(", "vcall_offset", "==", "0", ")", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "else", "{", "gcc_assert", "(", "(", "vcall_offset", "&", "(", "POINTER_BYTES", "-", "1", ")", ")", "==", "0", ")", ";", "addr", "=", "this_rtx", ";", "if", "(", "delta", "!=", "0", ")", "{", "if", "(", "delta", ">=", "-", "256", "&&", "delta", "<", "256", ")", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "this_rtx", ",", "plus_constant", "(", "Pmode", ",", "this_rtx", ",", "delta", ")", ")", ";", "else", "aarch64_add_offset", "(", "Pmode", ",", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp1", ",", "temp0", ",", "false", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp0", ",", "gen_rtx_ZERO_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "if", "(", "vcall_offset", ">=", "-", "256", "&&", "vcall_offset", "<", "4096", "*", "POINTER_BYTES", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "{", "aarch64_internal_mov_immediate", "(", "temp1", ",", "GEN_INT", "(", "vcall_offset", ")", ",", "true", ",", "Pmode", ")", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp0", ",", "temp1", ")", ";", "}", "if", "(", "Pmode", "==", "ptr_mode", ")", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ";", "else", "aarch64_emit_move", "(", "temp1", ",", "gen_rtx_SIGN_EXTEND", "(", "Pmode", ",", "gen_rtx_MEM", "(", "ptr_mode", ",", "addr", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "aarch64", "1", "0", "1", "0", "0", "256", "256", "256", "4096", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getNumInterleavedAccesses", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "return", "(", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", "+", "127", ")", "/", "128", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "interleaved", "accesses", "that", "will", "be", "generated", "when", "lowering", "accesses", "of", "the", "given", "type", "." ]

[ "ARM", "ARM", "127", "128" ]

[]

[ "<s>", "const", "M680x0RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "M680x0", "M680x0" ]

[]

[ "<s>", "X86MCTargetExpr", "*", "X86MCTargetExpr", "::", "Create", "(", "const", "MCSymbol", "*", "Sym", ",", "VariantKind", "K", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "X86MCTargetExpr", "(", "Sym", ",", "K", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "sh_attr_renesas_p", "(", "const_tree", "td", ")", "{", "if", "(", "TARGET_HITACHI", ")", "return", "true", ";", "if", "(", "td", "==", "NULL_TREE", ")", "return", "false", ";", "if", "(", "DECL_P", "(", "td", ")", ")", "td", "=", "TREE_TYPE", "(", "td", ")", ";", "if", "(", "td", "==", "error_mark_node", ")", "return", "false", ";", "return", "(", "lookup_attribute", "(", "\"renesas\"", ",", "TYPE_ATTRIBUTES", "(", "td", ")", ")", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "True", "if", "__attribute__", "(", "(", "renesas", ")", ")", "or", "-mrenesas", "." ]

[ "sh", "\"renesas\"" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "getGlobalBaseReg", "(", "bool", "IsForTls", ")", "{", "Register", "GlobalBaseReg", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ",", "IsForTls", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ",", "0", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "require_pic_register", "(", "void", ")", "{", "if", "(", "!", "crtl", "->", "uses_pic_offset_table", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "if", "(", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "!", "(", "TARGET_THUMB1", "&&", "arm_pic_register", ">", "LAST_LO_REGNUM", ")", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "pic_reg", ")", "cfun", "->", "machine", "->", "pic_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "arm_pic_register", ")", ";", "if", "(", "current_ir_type", "(", ")", "!=", "IR_GIMPLE", "||", "currently_expanding_to_rtl", ")", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "}", "else", "{", "rtx_insn", "*", "seq", ",", "*", "insn", ";", "if", "(", "!", "cfun", "->", "machine", "->", "pic_reg", ")", "cfun", "->", "machine", "->", "pic_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "current_ir_type", "(", ")", "!=", "IR_GIMPLE", "||", "currently_expanding_to_rtl", ")", "{", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "start_sequence", "(", ")", ";", "if", "(", "TARGET_THUMB1", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "arm_pic_register", ">", "LAST_LO_REGNUM", ")", "emit_move_insn", "(", "cfun", "->", "machine", "->", "pic_reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "arm_pic_register", ")", ")", ";", "else", "arm_load_pic_register", "(", "0UL", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "for", "(", "insn", "=", "seq", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "INSN_LOCATION", "(", "insn", ")", "=", "prologue_location", ";", "insert_insn_on_edge", "(", "seq", ",", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Record", "that", "the", "current", "function", "needs", "a", "PIC", "register", ".", "Initialize", "cfun-", ">", "machine-", ">", "pic_reg", "if", "we", "have", "not", "already", "done", "so", "." ]

[ "arm", "1", "1", "0UL" ]

[]

[ "<s>", "void", "function_expander", "::", "add_integer_operand", "(", "HOST_WIDE_INT", "x", ")", "{", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ",", "true", ")", ";", "create_integer_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "integer", "operand", "X", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_fp_cond", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "pred", ",", "bool", "known_ptrue_p", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "flag", "=", "gen_int_mode", "(", "known_ptrue_p", ",", "SImode", ")", ";", "rtx", "unspec", "=", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "pred", ")", ",", "gen_rtvec", "(", "4", ",", "pred", ",", "flag", ",", "op0", ",", "op1", ")", ",", "aarch64_unspec_cond_code", "(", "code", ")", ")", ";", "emit_set_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Emit", ":", "(", "set", "TARGET", "(", "unspec", "[", "PRED", "KNOWN_PTRUE_P", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", ")", "where", "<", "X", ">", "is", "the", "operation", "associated", "with", "comparison", "CODE", ".", "KNOWN_PTRUE_P", "is", "true", "if", "PRED", "is", "known", "to", "be", "a", "PTRUE", "." ]

[ "aarch64", "4" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "false", ";", "if", "(", "Imm", ".", "isNegZero", "(", ")", ")", "return", "false", ";", "return", "Imm", ".", "isZero", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "Mips", "Mips", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "static", "void", "mips_end_function_definition", "(", "const", "char", "*", "name", ")", "{", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.end\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\n\"", ",", "asm_out_file", ")", ";", "}", "}", "</s>" ]

[ "End", "a", "function", "definition", "started", "by", "mips_start_function_definition", "." ]

[ "mips", "\"\\t.end\\t\"", "\"\\n\"" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "XCoreDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint16_t", "insn16", ";", "if", "(", "!", "readInstruction16", "(", "Region", ",", "Address", ",", "Size", ",", "insn16", ")", ")", "{", "return", "Fail", ";", "}", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "instr", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "uint32_t", "insn32", ";", "if", "(", "!", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "insn32", ")", ")", "{", "return", "Fail", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "instr", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "XCore", "XCore", "2", "4" ]

[]

[ "<s>", "const", "RegisterBank", "&", "MipsRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "using", "namespace", "Mips", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirstRegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "SP32RegClassID", ":", "case", "Mips", "::", "GP32RegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ";", "case", "Mips", "::", "FGRCCRegClassID", ":", "case", "Mips", "::", "FGR32RegClassID", ":", "case", "Mips", "::", "FGR64RegClassID", ":", "case", "Mips", "::", "AFGR64RegClassID", ":", "case", "Mips", "::", "MSA128BRegClassID", ":", "case", "Mips", "::", "MSA128HRegClassID", ":", "case", "Mips", "::", "MSA128WRegClassID", ":", "case", "Mips", "::", "MSA128DRegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "FPRBRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "Mips", "Mips", "Mips", "Mips::GPR32RegClassID", "Mips::CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirstRegClassID", "Mips::CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", "Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", "Mips::SP32RegClassID", "Mips::GP32RegClassID", "Mips::GPRBRegBankID", "Mips::FGRCCRegClassID", "Mips::FGR32RegClassID", "Mips::FGR64RegClassID", "Mips::AFGR64RegClassID", "Mips::MSA128BRegClassID", "Mips::MSA128HRegClassID", "Mips::MSA128WRegClassID", "Mips::MSA128DRegClassID", "Mips::FPRBRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "static", "bool", "s390_single_field_struct_p", "(", "enum", "tree_code", "code", ",", "const_tree", "type", ",", "bool", "strict_size_check_p", ")", "{", "int", "empty_base_seen", "=", "0", ";", "bool", "zero_width_bf_skipped_p", "=", "false", ";", "const_tree", "orig_type", "=", "type", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "tree", "field", ",", "single_type", "=", "NULL_TREE", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "DECL_FIELD_ABI_IGNORED", "(", "field", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"no_unique_address\"", ",", "DECL_ATTRIBUTES", "(", "field", ")", ")", ")", "empty_base_seen", "|=", "2", ";", "else", "empty_base_seen", "|=", "1", ";", "continue", ";", "}", "if", "(", "DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD", "(", "field", ")", ")", "{", "zero_width_bf_skipped_p", "=", "true", ";", "continue", ";", "}", "if", "(", "single_type", "==", "NULL_TREE", ")", "single_type", "=", "TREE_TYPE", "(", "field", ")", ";", "else", "return", "false", ";", "}", "if", "(", "single_type", "==", "NULL_TREE", ")", "return", "false", ";", "if", "(", "zero_width_bf_skipped_p", "&&", "!", "warn_psabi", ")", "return", "false", ";", "if", "(", "strict_size_check_p", "&&", "(", "int_size_in_bytes", "(", "single_type", ")", "<=", "0", "||", "int_size_in_bytes", "(", "single_type", ")", "!=", "int_size_in_bytes", "(", "type", ")", ")", ")", "return", "false", ";", "type", "=", "single_type", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "code", ")", "return", "false", ";", "if", "(", "warn_psabi", ")", "{", "unsigned", "uid", "=", "TYPE_UID", "(", "TYPE_MAIN_VARIANT", "(", "orig_type", ")", ")", ";", "if", "(", "empty_base_seen", ")", "{", "static", "unsigned", "last_reported_type_uid_empty_base", ";", "if", "(", "uid", "!=", "last_reported_type_uid_empty_base", ")", "{", "last_reported_type_uid_empty_base", "=", "uid", ";", "const", "char", "*", "url", "=", "CHANGES_ROOT_URL", "\"gcc-10/changes.html#empty_base\"", ";", "if", "(", "empty_base_seen", "&", "1", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type %qT when C++17 \"", "\"is enabled changed to match C++14 %{in GCC 10.1%}\"", ",", "orig_type", ",", "url", ")", ";", "else", "inform", "(", "input_location", ",", "\"parameter passing for argument of type %qT with \"", "\"%<[[no_unique_address]]%> members changed \"", "\"%{in GCC 10.1%}\"", ",", "orig_type", ",", "url", ")", ";", "}", "}", "if", "(", "zero_width_bf_skipped_p", ")", "{", "static", "unsigned", "last_reported_type_uid_zero_width", ";", "if", "(", "uid", "!=", "last_reported_type_uid_zero_width", ")", "{", "last_reported_type_uid_zero_width", "=", "uid", ";", "inform", "(", "input_location", ",", "\"parameter passing for argument of type %qT with \"", "\"zero-width bit fields members changed in GCC 12\"", ",", "orig_type", ")", ";", "}", "}", "}", "return", "!", "zero_width_bf_skipped_p", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "variable", "of", "TYPE", "should", "be", "passed", "as", "single", "value", "with", "type", "CODE", ".", "If", "STRICT_SIZE_CHECK_P", "is", "true", "the", "sizes", "of", "the", "record", "type", "and", "the", "field", "type", "must", "match", ".", "The", "ABI", "says", "that", "record", "types", "with", "a", "single", "member", "are", "treated", "just", "like", "that", "member", "would", "be", ".", "This", "function", "is", "a", "helper", "to", "detect", "such", "cases", ".", "The", "function", "also", "produces", "the", "proper", "diagnostics", "for", "cases", "where", "the", "outcome", "might", "be", "different", "depending", "on", "the", "GCC", "version", "." ]

[ "s390", "0", "\"no_unique_address\"", "2", "1", "0", "\"gcc-10/changes.html#empty_base\"", "1", "\"parameter passing for argument of type %qT when C++17 \"", "\"is enabled changed to match C++14 %{in GCC 10.1%}\"", "\"parameter passing for argument of type %qT with \"", "\"%<[[no_unique_address]]%> members changed \"", "\"%{in GCC 10.1%}\"", "\"parameter passing for argument of type %qT with \"", "\"zero-width bit fields members changed in GCC 12\"" ]

[]

[ "<s>", "iterator_range", "<", "function_sym_iterator", ">", "HSACodeObject", "::", "functions", "(", ")", "const", "{", "return", "make_range", "(", "functions_begin", "(", ")", ",", "functions_end", "(", ")", ")", ";", "}", "</s>" ]

[ "Iterator", "range", "for", "functions", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "TargetTransformInfo", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "aarch64_use_return_insn_p", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "aarch64_layout_frame", "(", ")", ";", "return", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "we", "can", "use", "a", "simple_return", "insn", ".", "This", "function", "checks", "whether", "the", "callee", "saved", "stack", "is", "empty", ",", "which", "means", "no", "restore", "actions", "are", "need", ".", "The", "pro_and_epilogue", "will", "use", "this", "to", "check", "whether", "shrink-wrapping", "opt", "is", "feasible", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "auto", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_CALL", ")", "{", "OutMI", ".", "setOpcode", "(", "TII", "->", "pseudoToMCOpcode", "(", "AMDGPU", "::", "S_SWAPPC_B64", ")", ")", ";", "MCOperand", "Dest", ",", "Src", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ",", "Dest", ")", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ",", "Src", ")", ";", "OutMI", ".", "addOperand", "(", "Dest", ")", ";", "OutMI", ".", "addOperand", "(", "Src", ")", ";", "return", ";", "}", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_TCRETURN", ")", "{", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "}", "int", "MCOpcode", "=", "TII", "->", "pseudoToMCOpcode", "(", "Opcode", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "int", "FIIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MCOpcode", ",", "AMDGPU", "::", "OpName", "::", "fi", ")", ";", "if", "(", "FIIdx", ">=", "(", "int", ")", "OutMI", ".", "getNumOperands", "(", ")", ")", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "AMDGPU", "AMDGPU", "SI", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64", "AMDGPU::SI_CALL", "AMDGPU::S_SWAPPC_B64", "0", "1", "AMDGPU::SI_TCRETURN", "AMDGPU::S_SETPC_B64", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "bool", "aarch64_sve_ld1rq_operand_p", "(", "rtx", "op", ")", "{", "return", "aarch64_sve_ld1rq_ld1ro_operand_p", "(", "op", ",", "TImode", ",", "GET_MODE_INNER", "(", "GET_MODE", "(", "op", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "MEM", "operand", "for", "an", "SVE", "LD1RQ", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.amdgcn.dispatch.id\"", ",", "\"amdgpu-dispatch-id\"", "}", ",", "{", "\"llvm.trap\"", ",", "\"amdgpu-queue-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "Mesa3D", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "if", "(", "hasAddrSpaceCast", "(", "F", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"llvm.amdgcn.dispatch.id\"", "\"amdgpu-dispatch-id\"", "\"llvm.trap\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "static", "void", "aarch64_init_tme_builtins", "(", "void", ")", "{", "tree", "ftype_uint64_void", "=", "build_function_type_list", "(", "uint64_type_node", ",", "NULL", ")", ";", "tree", "ftype_void_void", "=", "build_function_type_list", "(", "void_type_node", ",", "NULL", ")", ";", "tree", "ftype_void_uint64", "=", "build_function_type_list", "(", "void_type_node", ",", "uint64_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_TME_BUILTIN_TSTART", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_tstart\"", ",", "ftype_uint64_void", ",", "AARCH64_TME_BUILTIN_TSTART", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_TME_BUILTIN_TTEST", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_ttest\"", ",", "ftype_uint64_void", ",", "AARCH64_TME_BUILTIN_TTEST", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_TME_BUILTIN_TCOMMIT", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_tcommit\"", ",", "ftype_void_void", ",", "AARCH64_TME_BUILTIN_TCOMMIT", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_TME_BUILTIN_TCANCEL", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_tcancel\"", ",", "ftype_void_uint64", ",", "AARCH64_TME_BUILTIN_TCANCEL", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "transactional", "memory", "extension", "(", "TME", ")", "builtins", "." ]

[ "aarch64", "\"__builtin_aarch64_tstart\"", "\"__builtin_aarch64_ttest\"", "\"__builtin_aarch64_tcommit\"", "\"__builtin_aarch64_tcancel\"" ]

[]

[ "<s>", "static", "void", "rs6000_set_default_type_attributes", "(", "tree", "type", ")", "{", "if", "(", "rs6000_default_long_calls", "&&", "(", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", ")", ")", "TYPE_ATTRIBUTES", "(", "type", ")", "=", "tree_cons", "(", "get_identifier", "(", "\"longcall\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "darwin_set_default_type_attributes", "(", "type", ")", ";", "}", "</s>" ]

[ "Set", "longcall", "attributes", "on", "all", "functions", "declared", "when", "rs6000_default_long_calls", "is", "true", "." ]

[ "rs6000", "\"longcall\"" ]

[]

[ "<s>", "const", "char", "*", "BlackfinTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "BFISD", "::", "CALL", ":", "return", "\"BFISD::CALL\"", ";", "case", "BFISD", "::", "RET_FLAG", ":", "return", "\"BFISD::RET_FLAG\"", ";", "case", "BFISD", "::", "Wrapper", ":", "return", "\"BFISD::Wrapper\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Blackfin", "0", "BFISD::CALL", "\"BFISD::CALL\"", "BFISD::RET_FLAG", "\"BFISD::RET_FLAG\"", "BFISD::Wrapper", "\"BFISD::Wrapper\"" ]

[]

[ "<s>", "static", "int", "group_barrier_needed", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ";", "int", "need_barrier", "=", "0", ";", "struct", "reg_flags", "flags", ";", "memset", "(", "&", "flags", ",", "0", ",", "sizeof", "(", "flags", ")", ")", ";", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "NOTE", ":", "case", "DEBUG_INSN", ":", "break", ";", "case", "BARRIER", ":", "break", ";", "case", "CODE_LABEL", ":", "memset", "(", "rws_insn", ",", "0", ",", "sizeof", "(", "rws_insn", ")", ")", ";", "return", "1", ";", "case", "CALL_INSN", ":", "flags", ".", "is_branch", "=", "1", ";", "flags", ".", "is_sibcall", "=", "SIBLING_CALL_P", "(", "insn", ")", ";", "memset", "(", "rws_insn", ",", "0", ",", "sizeof", "(", "rws_insn", ")", ")", ";", "if", "(", "(", "pat", "=", "prev_active_insn", "(", "insn", ")", ")", "&&", "CALL_P", "(", "pat", ")", ")", "{", "need_barrier", "=", "1", ";", "break", ";", "}", "need_barrier", "=", "rtx_needs_barrier", "(", "PATTERN", "(", "insn", ")", ",", "flags", ",", "0", ")", ";", "break", ";", "case", "JUMP_INSN", ":", "if", "(", "!", "ia64_spec_check_p", "(", "insn", ")", ")", "flags", ".", "is_branch", "=", "1", ";", "if", "(", "(", "pat", "=", "prev_active_insn", "(", "insn", ")", ")", "&&", "CALL_P", "(", "pat", ")", ")", "{", "need_barrier", "=", "1", ";", "break", ";", "}", "case", "INSN", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "break", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_epilogue_deallocate_stack", ":", "case", "CODE_FOR_prologue_allocate_stack", ":", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "break", ";", "case", "CODE_FOR_doloop_end_internal", ":", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "break", ";", "case", "CODE_FOR_pred_rel_mutex", ":", "case", "CODE_FOR_prologue_use", ":", "return", "0", ";", "default", ":", "break", ";", "}", "memset", "(", "rws_insn", ",", "0", ",", "sizeof", "(", "rws_insn", ")", ")", ";", "need_barrier", "=", "rtx_needs_barrier", "(", "pat", ",", "flags", ",", "0", ")", ";", "if", "(", "!", "need_barrier", ")", "need_barrier", "=", "rws_access_regno", "(", "REG_VOLATILE", ",", "flags", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "first_instruction", "&&", "important_for_bundling_p", "(", "insn", ")", ")", "{", "need_barrier", "=", "0", ";", "first_instruction", "=", "0", ";", "}", "return", "need_barrier", ";", "}", "</s>" ]

[ "Given", "the", "current", "state", ",", "determine", "whether", "a", "group", "barrier", "(", "a", "stop", "bit", ")", "is", "necessary", "before", "INSN", ".", "Return", "nonzero", "if", "so", ".", "This", "modifies", "the", "state", "to", "include", "the", "effects", "of", "INSN", "as", "a", "side-effect", "." ]

[ "ia64", "0", "0", "0", "1", "1", "0", "1", "0", "1", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "get_bundle_name", "(", "int", "b", ")", "{", "return", "bundle_name", "[", "b", "]", ";", "}", "</s>" ]

[ "Map", "a", "bundle", "number", "to", "its", "pseudo-op", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vtrn", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "2", ")", "{", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "1", "]", "!=", "(", "(", "i", "+", "nelt", "+", "odd", ")", "&", "mask", ")", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vtrnv16qi_internal", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vtrnv8qi_internal", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vtrnv8hi_internal", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vtrnv4hi_internal", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vtrnv4si_internal", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vtrnv2si_internal", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vtrnv2sf_internal", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vtrnv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "odd", ")", "x", "=", "out0", ",", "out0", "=", "out1", ",", "out1", "=", "x", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VTRN", "insns", "." ]

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

[]

[ "<s>", "const", "HexagonSubtarget", "*", "HexagonTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeList", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "if", "(", "FnAttrs", ".", "hasFnAttribute", "(", "\"unsafe-fp-math\"", ")", "&&", "F", ".", "getFnAttribute", "(", "\"unsafe-fp-math\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "FS", "=", "FS", ".", "empty", "(", ")", "?", "\"+unsafe-fp\"", ":", "\"+unsafe-fp,\"", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "HexagonSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"target-cpu\"", "\"target-features\"", "\"unsafe-fp-math\"", "\"unsafe-fp-math\"", "\"true\"", "\"+unsafe-fp\"", "\"+unsafe-fp,\"", "Hexagon" ]

[]

[ "<s>", "bool", "GCNRegBankReassign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasRegisterBanking", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "LRM", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "MFI", "->", "getOccupancy", "(", ")", ";", "MaxNumVGPRs", "=", "ST", "->", "getMaxNumVGPRs", "(", "MF", ")", ";", "MaxNumSGPRs", "=", "ST", "->", "getMaxNumSGPRs", "(", "MF", ")", ";", "MaxNumVGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "MaxNumVGPRs", ")", ";", "MaxNumSGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "MaxNumSGPRs", ")", ";", "CSRegs", "=", "MRI", "->", "getCalleeSavedRegs", "(", ")", ";", "RegsUsed", ".", "resize", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", "+", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "SGPR_NULL", ")", "/", "2", "+", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== RegBanks reassign analysis on function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "unsigned", "StallCycles", "=", "collectCandidates", "(", "MF", ")", ";", "NumStallsDetected", "+=", "StallCycles", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== \"", "<<", "StallCycles", "<<", "\" stall cycles detected in \"", "\"function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "unsigned", "CyclesSaved", "=", "0", ";", "while", "(", "!", "Candidates", ".", "empty", "(", ")", ")", "{", "Candidate", "C", "=", "Candidates", ".", "back", "(", ")", ";", "unsigned", "LocalCyclesSaved", "=", "tryReassign", "(", "C", ")", ";", "CyclesSaved", "+=", "LocalCyclesSaved", ";", "if", "(", "VerifyStallCycles", ">", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "Candidates", ".", "pop_back", "(", ")", ";", "if", "(", "LocalCyclesSaved", ")", "{", "removeCandidates", "(", "C", ".", "Reg", ")", ";", "computeStallCycles", "(", "C", ".", "Reg", ",", "AMDGPU", "::", "NoRegister", ",", "-", "1", ",", "true", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "}", "}", "NumStallsRecovered", "+=", "CyclesSaved", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== After the pass \"", "<<", "CyclesSaved", "<<", "\" cycles saved in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "clear", "(", ")", ";", "if", "(", "VerifyStallCycles", "==", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "RegsUsed", ".", "clear", "(", ")", ";", "return", "CyclesSaved", ">", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_NULL", "2", "1", "\"=== RegBanks reassign analysis on function \"", "\"=== \"", "\" stall cycles detected in \"", "\"function \"", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "0", "1", "\"RegBank reassign stall cycles verification failed.\"", "AMDGPU::NoRegister", "1", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "\"=== After the pass \"", "\" cycles saved in function \"", "1", "\"RegBank reassign stall cycles verification failed.\"", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", "||", "Subtarget", ".", "hasVFP2Base", "(", ")", ")", "return", "(", "ScheduleHazardRecognizer", "*", ")", "new", "ARMHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "return", "TargetInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "SlotAlign", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "SlotAlign", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_ctr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrq_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxVRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrv_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxWRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrw_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "Hexagon::ModRegsRegClass", "Hexagon::LDriw_ctr", "0", "Hexagon::HvxQRRegClass", "Hexagon::PS_vloadrq_ai", "0", "Hexagon::HvxVRRegClass", "Hexagon::PS_vloadrv_ai", "0", "Hexagon::HvxWRRegClass", "Hexagon::PS_vloadrw_ai", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "const", "struct", "processor", "*", "aarch64_get_arch", "(", "enum", "aarch64_arch", "arch", ")", "{", "if", "(", "arch", "!=", "aarch64_no_arch", ")", "return", "&", "all_architectures", "[", "arch", "]", ";", "const", "struct", "processor", "*", "cpu", "=", "&", "all_cores", "[", "TARGET_CPU_DEFAULT", "&", "0x3f", "]", ";", "return", "&", "all_architectures", "[", "cpu", "->", "arch", "]", ";", "}", "</s>" ]

[ "Return", "the", "architecture", "corresponding", "to", "the", "enum", "ARCH", ".", "If", "it", "does", "n't", "specify", "a", "valid", "architecture", ",", "return", "the", "default", "." ]

[ "aarch64", "0x3f" ]

[]

[ "<s>", "MCOperand", "LM32MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "return", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "default", ":", "return", "MCOperand", "::", "CreateExpr", "(", "getExpr", "(", "MO", ")", ")", ";", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "LM32", "LM32" ]

[]

[ "<s>", "bool", "hasCompressedExport", "(", ")", "const", "{", "return", "!", "GFX11Insts", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "'s", "EXP", "instruction", "has", "the", "COMPR", "flag", ",", "which", "affects", "the", "meaning", "of", "the", "EN", "(", "enable", ")", "bits", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "rtx", "function_expander", "::", "generate_insn", "(", "insn_code", "icode", ")", "{", "gcc_assert", "(", "opno", "==", "insn_data", "[", "icode", "]", ".", "n_generator_args", ")", ";", "if", "(", "!", "maybe_expand_insn", "(", "icode", ",", "opno", ",", "m_ops", ")", ")", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "NULL_RTX", ";", "}", "return", "function_returns_void_p", "(", ")", "?", "const0_rtx", ":", "m_ops", "[", "0", "]", ".", "value", ";", "}", "</s>" ]

[ "Generate", "instruction", "ICODE", ",", "given", "that", "its", "operands", "have", "already", "been", "added", "to", "M_OPS", ".", "Return", "the", "value", "of", "the", "first", "operand", "." ]

[ "riscv", "\"invalid argument to built-in function\"", "0" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AMDGPURegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "&", "RC", "==", "&", "AMDGPU", "::", "SReg_1RegClass", ")", "return", "AMDGPU", "::", "VCCRegBank", ";", "if", "(", "TRI", "->", "isSGPRClass", "(", "&", "RC", ")", ")", "return", "AMDGPU", "::", "SGPRRegBank", ";", "if", "(", "TRI", "->", "isAGPRClass", "(", "&", "RC", ")", ")", "return", "AMDGPU", "::", "AGPRRegBank", ";", "return", "AMDGPU", "::", "VGPRRegBank", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SReg_1RegClass", "AMDGPU::VCCRegBank", "AMDGPU::SGPRRegBank", "AMDGPU::AGPRRegBank", "AMDGPU::VGPRRegBank" ]

[]

[ "<s>", "void", "JVMAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "return", ";", "}", "</s>" ]

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

[ "JVM", "JVM" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "int", "Offset", "=", "(", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "+", "(", "-", "(", "spOffset", "+", "4", ")", ")", ")", ":", "(", "spOffset", ")", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Mips", "Mips", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "1" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Xtensa" ]

[]

[ "<s>", "static", "bool", "aarch64_option_valid_attribute_p", "(", "tree", "fndecl", ",", "tree", ",", "tree", "args", ",", "int", ")", "{", "struct", "cl_target_option", "cur_target", ";", "bool", "ret", ";", "tree", "old_optimize", ";", "tree", "new_target", ",", "new_optimize", ";", "tree", "existing_target", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "!", "existing_target", "&&", "args", "==", "current_target_pragma", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "target_option_current_node", ";", "return", "true", ";", "}", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "func_optimize", "&&", "func_optimize", "!=", "old_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_save", "(", "&", "cur_target", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "existing_target", ")", "{", "struct", "cl_target_option", "*", "existing_options", "=", "TREE_TARGET_OPTION", "(", "existing_target", ")", ";", "if", "(", "existing_options", ")", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "existing_options", ")", ";", "}", "else", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "target_option_current_node", ")", ")", ";", "ret", "=", "aarch64_process_target_attr", "(", "args", ")", ";", "if", "(", "ret", ")", "{", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "if", "(", "TARGET_SIMD", ")", "{", "tree", "saved_current_target_pragma", "=", "current_target_pragma", ";", "current_target_pragma", "=", "NULL", ";", "aarch64_init_simd_builtins", "(", ")", ";", "current_target_pragma", "=", "saved_current_target_pragma", ";", "}", "new_target", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "else", "new_target", "=", "NULL", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "fndecl", "&&", "ret", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "cur_target", ")", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_OPTIMIZATION", "(", "old_optimize", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_VALID_ATTRIBUTE_P", ".", "This", "is", "used", "to", "process", "attribute", "(", "(", "target", "(", "``", "...", "''", ")", ")", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "i386_pe_asm_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "HOST_WIDE_INT", "size", ",", "HOST_WIDE_INT", "align", ")", "{", "HOST_WIDE_INT", "rounded", ";", "rounded", "=", "size", "?", "size", ":", "1", ";", "rounded", "+=", "(", "BIGGEST_ALIGNMENT", "/", "BITS_PER_UNIT", ")", "-", "1", ";", "rounded", "=", "(", "rounded", "/", "(", "BIGGEST_ALIGNMENT", "/", "BITS_PER_UNIT", ")", "*", "(", "BIGGEST_ALIGNMENT", "/", "BITS_PER_UNIT", ")", ")", ";", "i386_pe_maybe_record_exported_symbol", "(", "decl", ",", "name", ",", "1", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.comm\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "if", "(", "use_pe_aligned_common", ")", "fprintf", "(", "stream", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\", %d\\n\"", ",", "size", "?", "size", ":", "(", "HOST_WIDE_INT", ")", "1", ",", "exact_log2", "(", "align", ")", "-", "exact_log2", "(", "CHAR_BIT", ")", ")", ";", "else", "fprintf", "(", "stream", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\t\"", "ASM_COMMENT_START", "\" \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "rounded", ",", "size", ")", ";", "}", "</s>" ]

[ "Beware", ",", "DECL", "may", "be", "NULL", "if", "compile_file", "(", ")", "is", "emitting", "the", "LTO", "marker", "." ]

[ "i386", "1", "1", "1", "\"\\t.comm\\t\"", "\", \"", "\", %d\\n\"", "1", "\", \"", "\"\\t\"", "\" \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "WebAssemblyFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Call", ":", "if", "(", "selectCall", "(", "I", ")", ")", "return", "true", ";", "break", ";", "case", "Instruction", "::", "Select", ":", "return", "selectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "selectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "selectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "SExt", ":", "return", "selectSExt", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "return", "selectICmp", "(", "I", ")", ";", "case", "Instruction", "::", "FCmp", ":", "return", "selectFCmp", "(", "I", ")", ";", "case", "Instruction", "::", "BitCast", ":", "return", "selectBitCast", "(", "I", ")", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBr", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "selectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Unreachable", ":", "return", "selectUnreachable", "(", "I", ")", ";", "default", ":", "break", ";", "}", "return", "selectOperator", "(", "I", ",", "I", "->", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "unsigned", "OR1KTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "OR1K", "::", "R4", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "OR1K", "OR1K", "OR1K::R4" ]

[]

[ "<s>", "bool", "useAA", "(", ")", "const", "override", "{", "return", "UseAA", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "void", "emit_load_locked", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "fn", "=", "gen_load_lockedqi", ";", "break", ";", "case", "E_HImode", ":", "fn", "=", "gen_load_lockedhi", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "GET_MODE", "(", "mem", ")", "==", "QImode", ")", "fn", "=", "gen_load_lockedqi_si", ";", "else", "if", "(", "GET_MODE", "(", "mem", ")", "==", "HImode", ")", "fn", "=", "gen_load_lockedhi_si", ";", "else", "fn", "=", "gen_load_lockedsi", ";", "break", ";", "case", "E_DImode", ":", "fn", "=", "gen_load_lockeddi", ";", "break", ";", "case", "E_TImode", ":", "fn", "=", "gen_load_lockedti", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "nvptx_cpu_cpp_builtins", "(", "void", ")", "{", "cpp_assert", "(", "parse_in", ",", "\"machine=nvptx\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"cpu=nvptx\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__nvptx__\"", ")", ";", "if", "(", "TARGET_SOFT_STACK", ")", "cpp_define", "(", "parse_in", ",", "\"__nvptx_softstack__\"", ")", ";", "if", "(", "TARGET_UNIFORM_SIMT", ")", "cpp_define", "(", "parse_in", ",", "\"__nvptx_unisimt__\"", ")", ";", "const", "char", "*", "ptx_sm", "=", "NULL", ";", "{", "\\", "if", "(", "TARGET_SM", "##", "XX", ")", "\\", "ptx_sm", "=", "\"__PTX_SM__=\"", "#", "XX", "\"0\"", ";", "\\", "}", "cpp_define", "(", "parse_in", ",", "ptx_sm", ")", ";", "{", "unsigned", "major", "=", "ptx_version_to_number", "(", "(", "ptx_version", ")", "ptx_version_option", ",", "true", ")", ";", "unsigned", "minor", "=", "ptx_version_to_number", "(", "(", "ptx_version", ")", "ptx_version_option", ",", "false", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__PTX_ISA_VERSION_MAJOR__=%u\"", ",", "major", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__PTX_ISA_VERSION_MINOR__=%u\"", ",", "minor", ")", ";", "}", "}", "</s>" ]

[ "Function", "to", "tell", "the", "preprocessor", "about", "the", "defines", "for", "the", "target", "." ]

[ "nvptx", "\"machine=nvptx\"", "\"cpu=nvptx\"", "\"__nvptx__\"", "\"__nvptx_softstack__\"", "\"__nvptx_unisimt__\"", "\"__PTX_SM__=\"", "\"0\"", "\"__PTX_ISA_VERSION_MAJOR__=%u\"", "\"__PTX_ISA_VERSION_MINOR__=%u\"" ]

[]

[ "<s>", "void", "SystemZMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isImplicit", "(", ")", ")", "OutMI", ".", "addOperand", "(", "lowerOperand", "(", "MO", ")", ")", ";", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "bool", "mem_locations_overlap", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "reg1", ",", "reg2", ";", "HOST_WIDE_INT", "off1", ",", "size1", ",", "off2", ",", "size2", ";", "if", "(", "get_memref_parts", "(", "mem1", ",", "&", "reg1", ",", "&", "off1", ",", "&", "size1", ")", "&&", "get_memref_parts", "(", "mem2", ",", "&", "reg2", ",", "&", "off2", ",", "&", "size2", ")", ")", "return", "(", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", ")", "&&", "(", "(", "(", "off1", "<=", "off2", ")", "&&", "(", "off1", "+", "size1", ">", "off2", ")", ")", "||", "(", "(", "off2", "<=", "off1", ")", "&&", "(", "off2", "+", "size2", ">", "off1", ")", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "it", "can", "be", "determined", "that", "the", "two", "MEM", "locations", "overlap", "by", "at", "least", "1", "byte", "based", "on", "base", "reg/offset/size", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "Cpu0AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0MachineFunctionInfo", ">", "(", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "int", "ARMAsmParser", "::", "tryParseRegister", "(", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "1", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"r13\"", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "\"r14\"", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "\"r15\"", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "\"ip\"", ",", "ARM", "::", "R12", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "!", "RegNum", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "ARM", "ARM", "1", "\"r13\"", "ARM::SP", "\"r14\"", "ARM::LR", "\"r15\"", "ARM::PC", "\"ip\"", "ARM::R12", "0", "1" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d8TPseudo", ":", "case", "ARM", "::", "VLD1d16TPseudo", ":", "case", "ARM", "::", "VLD1d32TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d8QPseudo", ":", "case", "ARM", "::", "VLD1d16QPseudo", ":", "case", "ARM", "::", "VLD1d32QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "ARM::VLD1d8TPseudo", "ARM::VLD1d16TPseudo", "ARM::VLD1d32TPseudo", "ARM::VLD1d64TPseudo", "ARM::VLD1d8QPseudo", "ARM::VLD1d16QPseudo", "ARM::VLD1d32QPseudo", "ARM::VLD1d64QPseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ",", "fp_saved", ";", "local_cum", "=", "*", "cum", ";", "FUNCTION_ARG_ADVANCE", "(", "local_cum", ",", "mode", ",", "type", ",", "1", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "fp_saved", "=", "(", "EABI_FLOAT_VARARGS_P", "?", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_fprs", ":", "0", ")", ";", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "enum", "machine_mode", "mode", ";", "int", "off", ",", "i", ";", "off", "=", "-", "gp_saved", "*", "UNITS_PER_WORD", ";", "off", "&=", "~", "(", "UNITS_PER_FPVALUE", "-", "1", ")", ";", "off", "-=", "fp_saved", "*", "UNITS_PER_FPREG", ";", "mode", "=", "TARGET_SINGLE_FLOAT", "?", "SFmode", ":", "DFmode", ";", "for", "(", "i", "=", "local_cum", ".", "num_fprs", ";", "i", "<", "MAX_ARGS_IN_REGISTERS", ";", "i", "+=", "FP_INC", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "FP_ARG_FIRST", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_HWFPVALUE", ";", "}", "}", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", "+", "fp_saved", "*", "UNITS_PER_FPREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "mips", "1", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "Mips16TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "ARMOperand", "*", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "CPUName", "=", "selectMipsCPU", "(", "TT", ",", "CPUName", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", "->", "Options", ".", "UseSoftFloat", ")", "{", "TM", "->", "Options", ".", "UseSoftFloat", "=", "true", ";", "TM", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "InMips16HardFloat", "=", "true", ";", "}", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "assert", "(", "MipsABI", "!=", "UnknownABI", ")", ";", "assert", "(", "(", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureO32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureEABI", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN64", ")", "!=", "0", ")", ")", "==", "1", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "if", "(", "inMips16Mode", "(", ")", ")", "HasBitCount", "=", "false", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::FeatureO32", "0", "Mips::FeatureEABI", "0", "Mips::FeatureN32", "0", "Mips::FeatureN64", "0", "1", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"linux\"", "Mips" ]

[]

[ "<s>", "static", "rtx", "arm_expand_mve_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", ">=", "ARM_BUILTIN_MVE_BASE", "&&", "!", "TARGET_HAVE_MVE", ")", "{", "fatal_error", "(", "input_location", ",", "\"You must enable MVE instructions\"", "\" to use these intrinsics\"", ")", ";", "return", "const0_rtx", ";", "}", "arm_builtin_datum", "*", "d", "=", "&", "mve_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_MVE_PATTERN_START", "]", ";", "return", "arm_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", ",", "d", ")", ";", "}", "</s>" ]

[ "Expand", "an", "MVE", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "their", "respective", "target", "constraints", "are", "met", ".", "This", "check", "happens", "within", "arm_expand_builtin", "." ]

[ "arm", "\"You must enable MVE instructions\"", "\" to use these intrinsics\"" ]

[]

[ "<s>", "bool", "Z80FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "Z80MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "Z80MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "i", "--", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "TII", ".", "get", "(", "Z80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "Z80", "Z80", "Z80", "Z80", "2", "0", "1", "Z80::PUSH16r" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "TVM" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "SelectBitcast", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SelectIntrinsicWChain", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "case", "HexagonISD", "::", "VALIGN", ":", "return", "SelectVAlign", "(", "N", ")", ";", "case", "HexagonISD", "::", "VALIGNADDR", ":", "return", "SelectVAlignAddr", "(", "N", ")", ";", "case", "HexagonISD", "::", "TYPECAST", ":", "return", "SelectTypecast", "(", "N", ")", ";", "case", "HexagonISD", "::", "P2D", ":", "return", "SelectP2D", "(", "N", ")", ";", "case", "HexagonISD", "::", "D2P", ":", "return", "SelectD2P", "(", "N", ")", ";", "case", "HexagonISD", "::", "Q2V", ":", "return", "SelectQ2V", "(", "N", ")", ";", "case", "HexagonISD", "::", "V2Q", ":", "return", "SelectV2Q", "(", "N", ")", ";", "}", "if", "(", "HST", "->", "useHVXOps", "(", ")", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "SelectHvxShuffle", "(", "N", ")", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "SelectHvxRor", "(", "N", ")", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::BITCAST", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN", "HexagonISD::VALIGN", "HexagonISD::VALIGNADDR", "HexagonISD::TYPECAST", "HexagonISD::P2D", "HexagonISD::D2P", "HexagonISD::Q2V", "HexagonISD::V2Q", "ISD::VECTOR_SHUFFLE", "HexagonISD::VROR" ]

[]

[ "<s>", "static", "void", "arm32_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "bool", "long_call_p", "=", "arm_is_long_call_p", "(", "function", ")", ";", "int", "this_regno", "=", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "R1_REGNUM", ":", "R0_REGNUM", ")", ";", "rtx", "temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP_REGNUM", ")", ";", "rtx", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "this_regno", ")", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "delta", "!=", "0", ")", "arm_split_constant", "(", "PLUS", ",", "Pmode", ",", "NULL_RTX", ",", "delta", ",", "this_rtx", ",", "this_rtx", ",", "false", ")", ";", "if", "(", "vcall_offset", "!=", "0", ")", "{", "emit_move_insn", "(", "temp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "arm_split_constant", "(", "PLUS", ",", "Pmode", ",", "NULL_RTX", ",", "vcall_offset", ",", "temp", ",", "temp", ",", "false", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "temp", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "temp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "rtx", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "long_call_p", ")", "{", "emit_move_insn", "(", "temp", ",", "funexp", ")", ";", "funexp", "=", "temp", ";", "}", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "rtx_insn", "*", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ",", "NULL_RTX", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "emit_barrier", "(", ")", ";", "if", "(", "long_call_p", ")", "{", "split_all_insns_noflow", "(", ")", ";", "arm_reorg", "(", ")", ";", "}", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "MI", "thunk", "handling", "for", "TARGET_32BIT", "." ]

[ "arm", "1", "0", "0", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "emitEXRLTargetInstructions", "(", ")", ";", "emitStackMaps", "(", "SM", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "nvptx_record_fndecl", "(", "tree", "decl", ")", "{", "tree", "*", "slot", "=", "declared_fndecls_htab", "->", "find_slot", "(", "decl", ",", "INSERT", ")", ";", "if", "(", "*", "slot", "==", "NULL", ")", "{", "*", "slot", "=", "decl", ";", "const", "char", "*", "name", "=", "get_fnname_from_decl", "(", "decl", ")", ";", "write_fn_proto", "(", "func_decls", ",", "false", ",", "name", ",", "decl", ")", ";", "}", "}", "</s>" ]

[ "DECL", "is", "an", "external", "FUNCTION_DECL", ",", "make", "sure", "its", "in", "the", "fndecl", "hash", "table", "and", "and", "write", "a", "ptx", "prototype", ".", "These", "are", "emitted", "at", "end", "of", "compilation", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisablePacketizer", "||", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "Begin", "=", "MB", ".", "begin", "(", ")", ",", "End", "=", "MB", ".", "end", "(", ")", ";", "while", "(", "Begin", "!=", "End", ")", "{", "MachineBasicBlock", "::", "iterator", "RB", "=", "Begin", ";", "while", "(", "RB", "!=", "End", "&&", "HII", "->", "isSchedulingBoundary", "(", "*", "RB", ",", "&", "MB", ",", "MF", ")", ")", "++", "RB", ";", "MachineBasicBlock", "::", "iterator", "RE", "=", "RB", ";", "while", "(", "RE", "!=", "End", "&&", "!", "HII", "->", "isSchedulingBoundary", "(", "*", "RE", ",", "&", "MB", ",", "MF", ")", ")", "++", "RE", ";", "if", "(", "RE", "!=", "End", ")", "++", "RE", ";", "if", "(", "RB", "!=", "End", ")", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "RB", ",", "RE", ")", ";", "Begin", "=", "RE", ";", "}", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "OR1KRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "*", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "*", "MF", ")", "?", "CSR_FP_SaveList", ":", "CSR_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "rtx_insn", "*", "arm_pic_static_addr", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx", "l1", ",", "labelno", ",", "offset_rtx", ";", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "flag_pic", ")", ";", "bool", "is_readonly", "=", "false", ";", "bool", "info_known", "=", "false", ";", "if", "(", "TARGET_FDPIC", "&&", "SYMBOL_REF_P", "(", "orig", ")", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "orig", ")", ")", "info_known", "=", "arm_is_segment_info_known", "(", "orig", ",", "&", "is_readonly", ")", ";", "if", "(", "TARGET_FDPIC", "&&", "SYMBOL_REF_P", "(", "orig", ")", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "orig", ")", "&&", "!", "info_known", ")", "{", "rtx", "pic_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "FDPIC_REGNUM", ")", ";", "insn", "=", "calculate_pic_address_constant", "(", "reg", ",", "pic_reg", ",", "orig", ")", ";", "}", "else", "if", "(", "TARGET_FDPIC", "&&", "SYMBOL_REF_P", "(", "orig", ")", "&&", "(", "SYMBOL_REF_FUNCTION_P", "(", "orig", ")", "||", "!", "is_readonly", ")", ")", "{", "rtx", "pic_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "FDPIC_REGNUM", ")", ";", "rtx", "l1", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "orig", ")", ",", "UNSPEC_PIC_SYM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "l1", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "pic_reg", ")", ")", ";", "}", "else", "{", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "l1", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "l1", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "l1", ")", ";", "offset_rtx", "=", "plus_constant", "(", "Pmode", ",", "l1", ",", "TARGET_ARM", "?", "8", ":", "4", ")", ";", "offset_rtx", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "orig", ",", "offset_rtx", ")", ",", "UNSPEC_SYMBOL_OFFSET", ")", ";", "offset_rtx", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset_rtx", ")", ";", "insn", "=", "emit_insn", "(", "gen_pic_load_addr_unified", "(", "reg", ",", "offset_rtx", ",", "labelno", ")", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "the", "address", "of", "a", "static", "var", "when", "flag_pic", "is", "set", "." ]

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

[]

[ "<s>", "MCObjectWriter", "*", "MipsAsmBackend", "::", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMipsELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ",", "IsLittle", ",", "Is64Bit", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbol", "(", "rtx", "x", ",", "rtx", "offset", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_LARGE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_TINY", ":", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_LARGE", ")", "{", "if", "(", "nopcrelative_literal_loads", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "else", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "if", "(", "aarch64_tls_symbol_p", "(", "x", ")", ")", "return", "aarch64_classify_tls_symbol", "(", "x", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "INTVAL", "(", "offset", ")", "<", "-", "1048575", "||", "INTVAL", "(", "offset", ")", ">", "1048575", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "offset", ")", ",", "HOST_WIDE_INT_C", "(", "-", "4294967263", ")", ",", "HOST_WIDE_INT_C", "(", "4294967264", ")", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_TINY_GOT", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_SMALL_SPIC", "?", "SYMBOL_SMALL_GOT_28K", ":", "SYMBOL_SMALL_GOT_4G", ")", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "aarch64", "1048575", "1048575", "4294967263", "4294967264" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "SW", ")", "||", "(", "Opc", "==", "Mips", "::", "SD", ")", "||", "(", "Opc", "==", "Mips", "::", "SWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "SDC164", ")", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Mips", "Mips", "Mips::SW", "Mips::SD", "Mips::SWC1", "Mips::SDC1", "Mips::SDC164", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "getOffsetOf", "(", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "return", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "}", "</s>" ]

[ "getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "bool", "AddressOf", "=", "false", ",", "SMLoc", "OffsetOfLoc", "=", "SMLoc", "(", ")", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ")", "{", "auto", "Res", "=", "std", "::", "make_unique", "<", "X86Operand", ">", "(", "Register", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Res", "->", "AddressOf", "=", "AddressOf", ";", "Res", "->", "OffsetOfLoc", "=", "OffsetOfLoc", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "return", "Res", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "X86", "X86", "X86" ]

[]

[ "<s>", "void", "pa_hpux_asm_output_external", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "gcc_assert", "(", "file", "==", "asm_out_file", ")", ";", "extern_symbol", "p", "=", "{", "decl", ",", "name", "}", ";", "vec_safe_push", "(", "extern_symbols", ",", "p", ")", ";", "}", "</s>" ]

[ "Mark", "DECL", "(", "name", "NAME", ")", "as", "an", "external", "reference", "(", "assembler", "output", "file", "FILE", ")", ".", "This", "saves", "the", "names", "to", "output", "at", "the", "end", "of", "the", "file", "if", "actually", "referenced", "." ]

[ "pa" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", "&&", "IsCallReloc", ")", "{", "unsigned", "GPReg", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "llvm", "::", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

[ "<s>", "const", "char", "*", "i386_pe_strip_name_encoding_full", "(", "const", "char", "*", "str", ")", "{", "const", "char", "*", "p", ";", "const", "char", "*", "name", "=", "i386_pe_strip_name_encoding", "(", "str", ")", ";", "if", "(", "*", "name", "==", "'@'", ")", "name", "++", ";", "p", "=", "strchr", "(", "name", ",", "'@'", ")", ";", "if", "(", "p", ")", "return", "ggc_alloc_string", "(", "name", ",", "p", "-", "name", ")", ";", "return", "name", ";", "}", "</s>" ]

[ "Also", "strip", "the", "fastcall", "prefix", "and", "stdcall", "suffix", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "TPCLatencyResolver", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "MF", "=", "&", "Fn", ";", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "ItinData", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrItineraryData", "(", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\\n*** TPC Latency Resolver\\n\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Processing BB#\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "MBB", ".", "empty", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "TPCNumDebugNops", ")", "{", "insertDebugNops", "(", "MBB", ",", "TPCNumDebugNops", ")", ";", "}", "else", "{", "resolveBlockLatency", "(", "MBB", ")", ";", "fixSmallLoops", "(", "MBB", ")", ";", "}", "}", "if", "(", "TPCNumDebugNops", ")", "{", "return", "true", ";", "}", "else", "resolveFunctionLatency", "(", "Fn", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "resolveCrossBlockLatency", "(", "MBB", ")", ";", "}", "}", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "resolveCrossBlockLatency", "(", "MBB", ",", "false", ",", "true", ")", ";", "}", "}", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "fillLoopDelaySlot", "(", "MBB", ")", ";", "}", "}", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "ensureLoopEndAndJmpLatency", "(", "MBB", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\"\\n\\n*** TPC Latency Resolver\\n\\n\"", "\"Processing BB#\"", "\"\\n\"", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "int", "legitimate_const_double_p", "(", "rtx", "address", ")", "{", "long", "sval", "[", "2", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "address", ")", ",", "sval", ")", ";", "if", "(", "(", "sval", "[", "0", "]", "&", "0xffff", ")", "==", "0", "&&", "sval", "[", "1", "]", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "checks", "whether", "a", "real", "value", "can", "be", "encoded", "as", "a", "literal", ",", "i.e.", ",", "addressing", "mode", "27", ".", "In", "that", "mode", ",", "real", "values", "are", "one", "word", "values", ",", "so", "the", "remaining", "48", "bits", "have", "to", "be", "zero", "." ]

[ "pdp11", "2", "0", "0xffff", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", "&&", "VT", "==", "MVT", "::", "f64", ")", "return", "2", ";", "return", "PPCTargetLowering", "::", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "PowerPC", "PPC", "MVT::f64", "2", "PPC" ]

[]

[ "<s>", "void", "emitImportName", "(", "const", "MCSymbolWasm", "*", ",", "StringRef", ")", "override", "{", "}", "</s>" ]

[ ".import_name" ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MFI", "->", "getStackSize", "(", ")", ")", "&&", "needsFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "AArch64CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "4", "4", "0", "1", "0", "0", "0", "\"Regs / types mismatch\"", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "s390_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ",", "struct", "cl_target_option", "*", "ptr", "ATTRIBUTE_UNUSED", ")", "{", "opts", "->", "x_s390_cost_pointer", "=", "(", "long", ")", "processor_table", "[", "opts", "->", "x_s390_tune", "]", ".", "cost", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options", ".", "This", "is", "a", "hook", "function", "and", "also", "called", "internally", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "FISCAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".byte\"", ")", "return", "parseDirectiveWord", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".half\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".nword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "FISC", "FISC", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"", "\".byte\"", "1", "\".half\"", "2", "\".word\"", "4", "\".nword\"", "8", "\".xword\"", "8" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectSize", "(", "FrameIdx", ")", ">=", "(", "RC", "->", "getSize", "(", ")", "/", "8", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "(", "RC", "->", "getSize", "(", ")", "/", "8", ")", "==", "32", "?", "32", ":", "16", ";", "bool", "isAligned", "=", "(", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "\"Stack slot too small for store\"", "8", "32", "32", "16" ]

[]

[ "<s>", "static", "void", "mt_print_operand_simple_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "if", "(", "!", "addr", ")", "error", "(", "\"PRINT_OPERAND_ADDRESS, null pointer\"", ")", ";", "else", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s, #0\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "0", ";", "rtx", "offset", "=", "0", ";", "rtx", "arg0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "arg0", ")", "==", "REG", ")", "{", "reg", "=", "arg0", ";", "offset", "=", "arg1", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "REG", ")", "fatal_insn", "(", "\"PRINT_OPERAND_ADDRESS, 2 regs\"", ",", "addr", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "arg1", ")", "==", "REG", ")", "reg", "=", "arg1", ",", "offset", "=", "arg0", ";", "else", "if", "(", "CONSTANT_P", "(", "arg0", ")", "&&", "CONSTANT_P", "(", "arg1", ")", ")", "{", "fprintf", "(", "file", ",", "\"%s, #\"", ",", "reg_names", "[", "GPR_R0", "]", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "fprintf", "(", "file", ",", "\"%s, #\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "offset", ")", ";", "break", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"PRINT_OPERAND_ADDRESS, invalid insn #1\"", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "mt", "\"PRINT_OPERAND_ADDRESS, null pointer\"", "\"%s, #0\"", "0", "0", "0", "1", "\"PRINT_OPERAND_ADDRESS, 2 regs\"", "\"%s, #\"", "\"%s, #\"", "\"PRINT_OPERAND_ADDRESS, invalid insn #1\"" ]

[]

[ "<s>", "bool", "isCompare", "(", ")", "const", "{", "return", "isa", "<", "ICmpInst", ">", "(", "Operation", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "is", "a", "comparison", "." ]

[ "TPC" ]

[]

[ "<s>", "Value", "*", "RISCVTargetLowering", "::", "emitMaskedAtomicCmpXchgIntrinsic", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicCmpXchgInst", "*", "CI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "CmpVal", ",", "Value", "*", "NewVal", ",", "Value", "*", "Mask", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Value", "*", "Ordering", "=", "Builder", ".", "getInt32", "(", "static_cast", "<", "uint32_t", ">", "(", "Ord", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "AlignedAddr", "->", "getType", "(", ")", "}", ";", "Function", "*", "MaskedCmpXchg", "=", "Intrinsic", "::", "getDeclaration", "(", "CI", "->", "getModule", "(", ")", ",", "Intrinsic", "::", "riscv_masked_cmpxchg_i32", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall", "(", "MaskedCmpXchg", ",", "{", "AlignedAddr", ",", "CmpVal", ",", "NewVal", ",", "Mask", ",", "Ordering", "}", ")", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "cmpxchg", "using", "a", "target-specific", "intrinsic", "." ]

[ "RISCV", "RISCV", "Intrinsic::getDeclaration", "Intrinsic::riscv_masked_cmpxchg_i32" ]

[]

[ "<s>", "bool", "MipsHazardSchedule", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "MipsSubtarget", "*", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", "->", "hasMips32r6", "(", ")", "||", "STI", "->", "inMicroMipsMode", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "MipsInstrInfo", "*", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "MF", ".", "begin", "(", ")", ";", "FI", "!=", "MF", ".", "end", "(", ")", ";", "++", "FI", ")", "{", "for", "(", "Iter", "I", "=", "FI", "->", "begin", "(", ")", ";", "I", "!=", "FI", "->", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "TII", "->", "HasForbiddenSlot", "(", "*", "I", ")", ")", "continue", ";", "bool", "InsertNop", "=", "false", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "FI", "->", "end", "(", ")", "&&", "!", "TII", "->", "SafeInForbiddenSlot", "(", "*", "getNextMachineInstr", "(", "std", "::", "next", "(", "I", ")", ")", ")", ")", "{", "InsertNop", "=", "true", ";", "}", "else", "{", "for", "(", "auto", "*", "Succ", ":", "FI", "->", "successors", "(", ")", ")", "{", "if", "(", "FI", "->", "isLayoutSuccessor", "(", "Succ", ")", "&&", "getNextMachineInstr", "(", "Succ", "->", "begin", "(", ")", ")", "!=", "Succ", "->", "end", "(", ")", "&&", "!", "TII", "->", "SafeInForbiddenSlot", "(", "*", "getNextMachineInstr", "(", "Succ", "->", "begin", "(", ")", ")", ")", ")", "{", "InsertNop", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "InsertNop", ")", "{", "Changed", "=", "true", ";", "MIBundleBuilder", "(", "I", ")", ".", "append", "(", "BuildMI", "(", "MF", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Mips", "::", "NOP", ")", ")", ")", ";", "NumInsertedNops", "++", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::NOP" ]

[]

[ "<s>", "bool", "Z80InstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Z80 branch condition!\"", ")", ";", "Z80", "::", "CondCode", "CC", "=", "static_cast", "<", "Z80", "::", "CondCode", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "GetOppositeBranchCondition", "(", "CC", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "1", "\"Invalid Z80 branch condition!\"", "Z80::CondCode", "Z80::CondCode", "0", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MipsMCInstLower", "MCInstLowering", "(", "Mang", ",", "*", "MF", ",", "*", "this", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "if", "(", "isUnalignedLoadStore", "(", "Opc", ")", ")", "{", "MCInst", "Directive", ";", "Directive", ".", "setOpcode", "(", "Mips", "::", "MACRO", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "Directive", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "Directive", ".", "setOpcode", "(", "Mips", "::", "NOMACRO", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "Directive", ")", ";", "return", ";", "}", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Mips", "Mips", "128", "Mips", "Mips::MACRO", "Mips::NOMACRO" ]

[]

[ "<s>", "void", "AMDGPUAAWrapperPass", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "Cpu0InstPrinter", "::", "PrintSpecial", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "const", "char", "*", "Code", ")", "const", "{", "assert", "(", "strcmp", "(", "Code", ",", "\"arguments\"", ")", "==", "0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MI", "->", "getNumOperands", "(", ")", "-", "1", ";", "i", "++", ")", "{", "if", "(", "i", "!=", "0", ")", "{", "O", "<<", "\", \"", ";", "}", "O", "<<", "\"$r\"", "<<", "i", "<<", "\"|0\"", ";", "}", "}", "</s>" ]

[ "Print", "information", "related", "to", "the", "specified", "machine", "instr", "that", "is", "independent", "of", "the", "operand", ",", "and", "may", "be", "independent", "of", "the", "instr", "itself", "." ]

[ "Cpu0", "Cpu0", "\"arguments\"", "0", "0", "1", "0", "\", \"", "\"$r\"", "\"|0\"" ]

[]

[ "<s>", "Sparc", "::", "Fixups", "SparcMCExpr", "::", "getFixupKind", "(", "SparcMCExpr", "::", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled SparcMCExpr::VariantKind\"", ")", ";", "case", "VK_Sparc_LO", ":", "return", "Sparc", "::", "fixup_sparc_lo10", ";", "case", "VK_Sparc_HI", ":", "return", "Sparc", "::", "fixup_sparc_hi22", ";", "case", "VK_Sparc_H44", ":", "return", "Sparc", "::", "fixup_sparc_h44", ";", "case", "VK_Sparc_M44", ":", "return", "Sparc", "::", "fixup_sparc_m44", ";", "case", "VK_Sparc_L44", ":", "return", "Sparc", "::", "fixup_sparc_l44", ";", "case", "VK_Sparc_HH", ":", "return", "Sparc", "::", "fixup_sparc_hh", ";", "case", "VK_Sparc_HM", ":", "return", "Sparc", "::", "fixup_sparc_hm", ";", "case", "VK_Sparc_PC22", ":", "return", "Sparc", "::", "fixup_sparc_pc22", ";", "case", "VK_Sparc_PC10", ":", "return", "Sparc", "::", "fixup_sparc_pc10", ";", "case", "VK_Sparc_GOT22", ":", "return", "Sparc", "::", "fixup_sparc_got22", ";", "case", "VK_Sparc_GOT10", ":", "return", "Sparc", "::", "fixup_sparc_got10", ";", "case", "VK_Sparc_GOT13", ":", "return", "Sparc", "::", "fixup_sparc_got13", ";", "case", "VK_Sparc_13", ":", "return", "Sparc", "::", "fixup_sparc_13", ";", "case", "VK_Sparc_WPLT30", ":", "return", "Sparc", "::", "fixup_sparc_wplt30", ";", "case", "VK_Sparc_TLS_GD_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_hi22", ";", "case", "VK_Sparc_TLS_GD_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_lo10", ";", "case", "VK_Sparc_TLS_GD_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_add", ";", "case", "VK_Sparc_TLS_GD_CALL", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_call", ";", "case", "VK_Sparc_TLS_LDM_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_hi22", ";", "case", "VK_Sparc_TLS_LDM_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_lo10", ";", "case", "VK_Sparc_TLS_LDM_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_add", ";", "case", "VK_Sparc_TLS_LDM_CALL", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_call", ";", "case", "VK_Sparc_TLS_LDO_HIX22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_hix22", ";", "case", "VK_Sparc_TLS_LDO_LOX10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_lox10", ";", "case", "VK_Sparc_TLS_LDO_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_add", ";", "case", "VK_Sparc_TLS_IE_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_hi22", ";", "case", "VK_Sparc_TLS_IE_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_lo10", ";", "case", "VK_Sparc_TLS_IE_LD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_ld", ";", "case", "VK_Sparc_TLS_IE_LDX", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_ldx", ";", "case", "VK_Sparc_TLS_IE_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_add", ";", "case", "VK_Sparc_TLS_LE_HIX22", ":", "return", "Sparc", "::", "fixup_sparc_tls_le_hix22", ";", "case", "VK_Sparc_TLS_LE_LOX10", ":", "return", "Sparc", "::", "fixup_sparc_tls_le_lox10", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc::Fixups", "Sparc", "Sparc", "\"Unhandled SparcMCExpr::VariantKind\"", "Sparc", "Sparc::fixup_sparc_lo10", "Sparc", "Sparc::fixup_sparc_hi22", "Sparc", "Sparc::fixup_sparc_h44", "Sparc", "Sparc::fixup_sparc_m44", "Sparc", "Sparc::fixup_sparc_l44", "Sparc", "Sparc::fixup_sparc_hh", "Sparc", "Sparc::fixup_sparc_hm", "Sparc", "Sparc::fixup_sparc_pc22", "Sparc", "Sparc::fixup_sparc_pc10", "Sparc", "Sparc::fixup_sparc_got22", "Sparc", "Sparc::fixup_sparc_got10", "Sparc", "Sparc::fixup_sparc_got13", "Sparc", "Sparc::fixup_sparc_13", "Sparc", "Sparc::fixup_sparc_wplt30", "Sparc", "Sparc::fixup_sparc_tls_gd_hi22", "Sparc", "Sparc::fixup_sparc_tls_gd_lo10", "Sparc", "Sparc::fixup_sparc_tls_gd_add", "Sparc", "Sparc::fixup_sparc_tls_gd_call", "Sparc", "Sparc::fixup_sparc_tls_ldm_hi22", "Sparc", "Sparc::fixup_sparc_tls_ldm_lo10", "Sparc", "Sparc::fixup_sparc_tls_ldm_add", "Sparc", "Sparc::fixup_sparc_tls_ldm_call", "Sparc", "Sparc::fixup_sparc_tls_ldo_hix22", "Sparc", "Sparc::fixup_sparc_tls_ldo_lox10", "Sparc", "Sparc::fixup_sparc_tls_ldo_add", "Sparc", "Sparc::fixup_sparc_tls_ie_hi22", "Sparc", "Sparc::fixup_sparc_tls_ie_lo10", "Sparc", "Sparc::fixup_sparc_tls_ie_ld", "Sparc", "Sparc::fixup_sparc_tls_ie_ldx", "Sparc", "Sparc::fixup_sparc_tls_ie_add", "Sparc", "Sparc::fixup_sparc_tls_le_hix22", "Sparc", "Sparc::fixup_sparc_tls_le_lox10" ]

[]

[ "<s>", "static", "void", "aarch64_init_builtins", "(", ")", "{", "aarch64_general_init_builtins", "(", ")", ";", "aarch64_sve", "::", "init_builtins", "(", ")", ";", "SUBTARGET_INIT_BUILTINS", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "aarch64", "aarch64_sve::init_builtins" ]

[]

[ "<s>", "static", "void", "emit_push_sfr", "(", "rtx", "sfr", ",", "bool", "frame_related_p", ",", "bool", "clr_p", ",", "int", "treg", ")", "{", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "MEM_P", "(", "sfr", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "all_regs_rtx", "[", "treg", "]", ",", "sfr", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_push_byte", "(", "treg", ",", "frame_related_p", ")", ";", "if", "(", "clr_p", ")", "{", "insn", "=", "emit_move_insn", "(", "sfr", ",", "const0_rtx", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "SFR", "via", "tmp_reg", ".", "SFR", "is", "a", "MEM", "representing", "the", "memory", "location", "of", "the", "SFR", ".", "If", "CLR_P", "then", "clear", "the", "SFR", "after", "the", "push", "using", "zero_reg", "." ]

[ "avr", "1", "1" ]

[]

[ "<s>", "void", "ix86_reset_previous_fndecl", "(", "void", ")", "{", "tree", "new_tree", "=", "target_option_current_node", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "ix86_previous_fndecl", "=", "NULL_TREE", ";", "}", "</s>" ]

[ "Set", "targets", "globals", "to", "the", "default", "(", "or", "current", "#", "pragma", "GCC", "target", "if", "active", ")", ".", "Invalidate", "ix86_previous_fndecl", "cache", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "HexagonSplitTFRCondSets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "QTM", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBBb", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBBb", "!=", "MBBe", ";", "++", "MBBb", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBb", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", "->", "begin", "(", ")", ";", "MII", "!=", "MBB", "->", "end", "(", ")", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "int", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Hexagon", "::", "TFR_condset_rr", ")", "{", "int", "DestReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int", "SrcReg1", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "int", "SrcReg2", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "DestReg", "!=", "SrcReg1", ")", "{", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "TFR_cPt", ")", ",", "DestReg", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "SrcReg1", ")", ";", "}", "if", "(", "DestReg", "!=", "SrcReg2", ")", "{", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "TFR_cNotPt", ")", ",", "DestReg", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "SrcReg2", ")", ";", "}", "MII", "=", "MBB", "->", "erase", "(", "MI", ")", ";", "--", "MII", ";", "}", "else", "if", "(", "Opc", "==", "Hexagon", "::", "TFR_condset_ii", ")", "{", "int", "DestReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int", "SrcReg1", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "int", "Immed1", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "int", "Immed2", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "TFRI_cPt", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg1", ")", ".", "addImm", "(", "Immed1", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "TFRI_cNotPt", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg1", ")", ".", "addImm", "(", "Immed2", ")", ";", "MII", "=", "MBB", "->", "erase", "(", "MI", ")", ";", "--", "MII", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::TFR_condset_rr", "0", "2", "3", "Hexagon::TFR_cPt", "1", "Hexagon::TFR_cNotPt", "1", "Hexagon::TFR_condset_ii", "0", "1", "2", "3", "Hexagon::TFRI_cPt", "Hexagon::TFRI_cNotPt" ]

[]

[ "<s>", "AVRSubtarget", "::", "AVRSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "AVRTargetMachine", "&", "TM", ")", ":", "AVRGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", ")", ",", "TLInfo", "(", "TM", ",", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ",", "TSInfo", "(", ")", ",", "m_hasSRAM", "(", "false", ")", ",", "m_hasJMPCALL", "(", "false", ")", ",", "m_hasIJMPCALL", "(", "false", ")", ",", "m_hasEIJMPCALL", "(", "false", ")", ",", "m_hasADDSUBIW", "(", "false", ")", ",", "m_hasSmallStack", "(", "false", ")", ",", "m_hasMOVW", "(", "false", ")", ",", "m_hasLPM", "(", "false", ")", ",", "m_hasLPMX", "(", "false", ")", ",", "m_hasELPM", "(", "false", ")", ",", "m_hasELPMX", "(", "false", ")", ",", "m_hasSPM", "(", "false", ")", ",", "m_hasSPMX", "(", "false", ")", ",", "m_hasDES", "(", "false", ")", ",", "m_supportsRMW", "(", "false", ")", ",", "m_supportsMultiplication", "(", "false", ")", ",", "m_hasBREAK", "(", "false", ")", ",", "m_hasTinyEncoding", "(", "false", ")", ",", "ELFArch", "(", "false", ")", ",", "m_FeatureSetDummy", "(", "false", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "Creates", "an", "AVR", "subtarget", "." ]

[ "AVR", "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "static", "void", "rs6000_density_test", "(", "rs6000_cost_data", "*", "data", ")", "{", "const", "int", "DENSITY_PCT_THRESHOLD", "=", "85", ";", "const", "int", "DENSITY_SIZE_THRESHOLD", "=", "70", ";", "const", "int", "DENSITY_PENALTY", "=", "10", ";", "struct", "loop", "*", "loop", "=", "data", "->", "loop_info", ";", "basic_block", "*", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "int", "nbbs", "=", "loop", "->", "num_nodes", ";", "int", "vec_cost", "=", "data", "->", "cost", "[", "vect_body", "]", ",", "not_vec_cost", "=", "0", ";", "int", "i", ",", "density_pct", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nbbs", ";", "i", "++", ")", "{", "basic_block", "bb", "=", "bbs", "[", "i", "]", ";", "gimple_stmt_iterator", "gsi", ";", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "gimple", "*", "stmt", "=", "gsi_stmt", "(", "gsi", ")", ";", "stmt_vec_info", "stmt_info", "=", "vinfo_for_stmt", "(", "stmt", ")", ";", "if", "(", "!", "STMT_VINFO_RELEVANT_P", "(", "stmt_info", ")", "&&", "!", "STMT_VINFO_IN_PATTERN_P", "(", "stmt_info", ")", ")", "not_vec_cost", "++", ";", "}", "}", "free", "(", "bbs", ")", ";", "density_pct", "=", "(", "vec_cost", "*", "100", ")", "/", "(", "vec_cost", "+", "not_vec_cost", ")", ";", "if", "(", "density_pct", ">", "DENSITY_PCT_THRESHOLD", "&&", "vec_cost", "+", "not_vec_cost", ">", "DENSITY_SIZE_THRESHOLD", ")", "{", "data", "->", "cost", "[", "vect_body", "]", "=", "vec_cost", "*", "(", "100", "+", "DENSITY_PENALTY", ")", "/", "100", ";", "if", "(", "dump_enabled_p", "(", ")", ")", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"", ",", "density_pct", ",", "vec_cost", "+", "not_vec_cost", ",", "DENSITY_PENALTY", ")", ";", "}", "}", "</s>" ]

[ "Test", "for", "likely", "overcommitment", "of", "vector", "hardware", "resources", ".", "If", "a", "loop", "iteration", "is", "relatively", "large", ",", "and", "too", "large", "a", "percentage", "of", "instructions", "in", "the", "loop", "are", "vectorized", ",", "the", "cost", "model", "may", "not", "adequately", "reflect", "delays", "from", "unavailable", "vector", "resources", ".", "Penalize", "the", "loop", "body", "cost", "for", "this", "case", "." ]

[ "rs6000", "85", "70", "10", "0", "0", "100", "100", "100", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "LDWFI", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "XCore", "XCore", "XCore::LDWFI", "0" ]

[]

[ "<s>", "bool", "XCoreFTAOElim", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "EE", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "EE", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "FRAME_TO_ARGS_OFFSET", ")", "{", "MachineInstr", "*", "OldInst", "=", "MBBI", ";", "unsigned", "Reg", "=", "OldInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MBBI", "=", "TII", ".", "loadImmediate", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "StackSize", ")", ";", "OldInst", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore::FRAME_TO_ARGS_OFFSET", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createELFObjectWriter", "(", "new", "MBlazeELFObjectWriter", "(", "OSType", ")", ",", "OS", ",", "false", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "MBlaze", "MBlaze" ]

[]