Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "canonicalize_perm", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "int", "i", ",", "which", ",", "nelt", "=", "d", "->", "nelt", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "which", "|=", "(", "d", "->", "perm", "[", "i", "]", "<", "nelt", "?", "1", ":", "2", ")", ";", "d", "->", "one_operand_p", "=", "true", ";", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "if", "(", "!", "rtx_equal_p", "(", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", "{", "d", "->", "one_operand_p", "=", "false", ";", "break", ";", "}", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", "->", "perm", "[", "i", "]", "&=", "nelt", "-", "1", ";", "d", "->", "op0", "=", "d", "->", "op1", ";", "break", ";", "case", "1", ":", "d", "->", "op1", "=", "d", "->", "op0", ";", "break", ";", "}", "return", "(", "which", "==", "3", ")", ";", "}", "</s>" ]

[ "If", "a", "permutation", "only", "uses", "one", "operand", ",", "make", "it", "clear", ".", "Returns", "true", "if", "the", "permutation", "references", "both", "operands", "." ]

[ "i386", "0", "1", "2", "3", "2", "0", "1", "1", "3" ]

[]

[ "<s>", "void", "addChild", "(", "MRT", "*", "Tree", ")", "{", "Children", ".", "insert", "(", "Tree", ")", ";", "}", "</s>" ]

[ "addChild", "-", "Add", "a", "child", "scope", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "Size", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "reg_offset_addressing_ok_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V16QImode", ":", "case", "V8HImode", ":", "case", "V4SFmode", ":", "case", "V4SImode", ":", "case", "V2DFmode", ":", "case", "V2DImode", ":", "case", "V1TImode", ":", "case", "TImode", ":", "case", "TFmode", ":", "case", "KFmode", ":", "if", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", ")", "return", "false", ";", "break", ";", "case", "V4HImode", ":", "case", "V2SImode", ":", "case", "V1DImode", ":", "case", "V2SFmode", ":", "if", "(", "TARGET_PAIRED_FLOAT", ")", "return", "false", ";", "break", ";", "case", "SDmode", ":", "if", "(", "TARGET_NO_SDMODE_STACK", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Subroutines", "of", "rs6000_legitimize_address", "and", "rs6000_legitimate_address_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "frv_register_nop", "(", "rtx", "nop", ")", "{", "rtx_insn", "*", "nop_insn", "=", "make_insn_raw", "(", "nop", ")", ";", "SET_NEXT_INSN", "(", "nop_insn", ")", "=", "0", ";", "SET_PREV_INSN", "(", "nop_insn", ")", "=", "0", ";", "frv_nops", "[", "frv_num_nops", "++", "]", "=", "nop_insn", ";", "}", "</s>" ]

[ "Add", "an", "instruction", "with", "pattern", "NOP", "to", "frv_nops", "[", "]", "." ]

[ "frv", "0", "0" ]

[]

[ "<s>", "bool", "n13_consumed_by_e1_dep_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "return", "n13_alu_e1_insn_dep_reg_p", "(", "consumer", ",", "def_reg", ")", ";", "case", "TYPE_PBSADA", ":", "return", "pbsada_insn_ra_rb_dep_reg_p", "(", "consumer", ",", "def_reg", ")", ";", "case", "TYPE_PBSAD", ":", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "consumer", ")", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "0", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MMU", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "consumer", ")", ")", "==", "SET", ")", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "else", "return", "true", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "extract_branch_target_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "use_rtx", "=", "extract_mem_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_LOAD_MULTIPLE", ":", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "E1", ".", "Because", "the", "address", "generation", "unti", "is", "at", "E1", ",", "the", "address", "input", "should", "be", "ready", "at", "E1", ".", "Note", "that", "the", "branch", "target", "is", "also", "a", "kind", "of", "addresses", ",", "so", "we", "have", "to", "check", "it", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "static", "rtx", "frame_insn", "(", "rtx", "x", ")", "{", "x", "=", "emit_insn", "(", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "insn", "and", "mark", "it", "as", "frame", "related", ".", "FIXME", ":", "Rename", "this", "to", "emit_frame_insn", "." ]

[ "sh", "1" ]

[]

[ "<s>", "int", "compute_logical_op_cc", "(", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "intval", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0x55555555", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "det", "=", "(", "code", "!=", "AND", ")", "?", "intval", ":", "~", "intval", ";", "const", "unsigned", "HOST_WIDE_INT", "b0", "=", "(", "det", ">>", "0", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "b1", "=", "(", "det", ">>", "8", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "w0", "=", "(", "det", ">>", "0", ")", "&", "0xffff", ";", "const", "unsigned", "HOST_WIDE_INT", "w1", "=", "(", "det", ">>", "16", ")", "&", "0xffff", ";", "int", "lower_half_easy_p", "=", "0", ";", "int", "upper_half_easy_p", "=", "0", ";", "enum", "attr_cc", "cc", "=", "CC_CLOBBER", ";", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "b0", "!=", "0", "&&", "b1", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "break", ";", "case", "SImode", ":", "if", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "{", "lower_half_easy_p", "=", "(", "b0", "==", "0", "||", "b1", "==", "0", "||", "(", "code", "!=", "IOR", "&&", "w0", "==", "0xffff", ")", ")", ";", "upper_half_easy_p", "=", "(", "(", "code", "!=", "IOR", "&&", "w1", "==", "0xffff", ")", "||", "(", "code", "==", "AND", "&&", "w1", "==", "0xff00", ")", ")", ";", "}", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "w0", "!=", "0", "&&", "w1", "!=", "0", "&&", "!", "(", "lower_half_easy_p", "&&", "upper_half_easy_p", ")", "&&", "!", "(", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", "&&", "lower_half_easy_p", ")", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "else", "{", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "cc", ";", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "logical", "insn", "." ]

[ "h8300", "3", "2", "1", "2", "0x55555555", "0", "0xff", "8", "0xff", "0", "0xffff", "16", "0xffff", "0", "0", "0", "0", "0", "0", "0xffff", "0xffff", "0xff00", "0", "0", "0xffff", "0x8000", "0", "0xffff", "0x8000", "0" ]

[]

[ "<s>", "void", "JVMInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "llvm_unreachable", "(", "\"Unsupported copyPhysReg.\"", ")", ";", "}", "</s>" ]

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

[ "JVM", "JVM", "\"Unsupported copyPhysReg.\"" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSMSVCRT", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "auto", "*", "SecurityCheckCookie", "=", "cast", "<", "Function", ">", "(", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "nullptr", ")", ")", ";", "SecurityCheckCookie", "->", "setCallingConv", "(", "CallingConv", "::", "X86_FastCall", ")", ";", "SecurityCheckCookie", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "return", ";", "}", "if", "(", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "return", ";", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86", "\"__security_cookie\"", "\"__security_check_cookie\"", "X86", "1" ]

[]

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "!", "MBBId", "||", "BBInfo", "[", "MBBId", "-", "1", "]", ".", "postOffset", "(", ")", "<=", "BBInfo", "[", "MBBId", "]", ".", "Offset", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Verifying \"", "<<", "CPUsers", ".", "size", "(", ")", "<<", "\" CP users.\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", "+", "2", ",", "U", ".", "NegOk", ",", "true", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"OK\\n\"", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Out of range.\\n\"", ")", ";", "dumpBBs", "(", ")", ";", "DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "1", "\"Verifying \"", "\" CP users.\\n\"", "0", "2", "\"OK\\n\"", "\"Out of range.\\n\"", "\"Constant pool entry out of range!\"" ]

[]

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

[ "True", "if", "subtarget", "inserts", "the", "final", "scheduling", "pass", "on", "its", "own", "." ]

[ "MOS" ]

[]

[ "<s>", "const", "char", "*", "output_branch", "(", "int", "logic", ",", "rtx", "insn", ",", "rtx", "*", "operands", ")", "{", "switch", "(", "get_attr_length", "(", "insn", ")", ")", "{", "case", "6", ":", "if", "(", "!", "TARGET_RELAX", ")", "{", "int", "label", "=", "lf", "++", ";", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "if", "(", "final_sequence", "&&", "!", "INSN_ANNULLED_BRANCH_P", "(", "XVECEXP", "(", "final_sequence", ",", "0", ",", "0", ")", ")", "&&", "get_attr_length", "(", "XVECEXP", "(", "final_sequence", ",", "0", ",", "1", ")", ")", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tb%s%ss\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ",", "label", ")", ";", "print_slot", "(", "final_sequence", ")", ";", "}", "else", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tb%s\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "label", ")", ";", "output_asm_insn", "(", "\"bra\\t%l0\"", ",", "&", "op0", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"LF\"", ",", "label", ")", ";", "return", "\"\"", ";", "}", "case", "2", ":", "return", "logic", "?", "\"bt%.\\t%l0\"", ":", "\"bf%.\\t%l0\"", ";", "case", "8", ":", "if", "(", "!", "TARGET_RELAX", ")", "{", "int", "label", "=", "lf", "++", ";", "gcc_assert", "(", "!", "final_sequence", "||", "!", "(", "INSN_ANNULLED_BRANCH_P", "(", "XVECEXP", "(", "final_sequence", ",", "0", ",", "0", ")", ")", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"b%s%ss\\t%LLF%d\\n\"", ",", "logic", "?", "\"f\"", ":", "\"t\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ",", "label", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "output_asm_insn", "(", "\"bra\\t%l0\"", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tnop\\n\"", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"LF\"", ",", "label", ")", ";", "return", "\"\"", ";", "}", "case", "4", ":", "{", "char", "buffer", "[", "10", "]", ";", "sprintf", "(", "buffer", ",", "\"b%s%ss\\t%%l0\"", ",", "logic", "?", "\"t\"", ":", "\"f\"", ",", "ASSEMBLER_DIALECT", "?", "\"/\"", ":", "\".\"", ")", ";", "output_asm_insn", "(", "buffer", ",", "&", "operands", "[", "0", "]", ")", ";", "return", "\"nop\"", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "conditional/unconditional", "branch", "to", "LABEL", ".", "COND", "is", "the", "string", "condition", ".", "INSN", "is", "the", "instruction", "." ]

[ "sh", "6", "0", "0", "0", "0", "1", "\"\\tb%s%ss\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"/\"", "\".\"", "\"\\tb%s\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"bra\\t%l0\"", "\"\\tnop\\n\"", "\"LF\"", "\"\"", "2", "\"bt%.\\t%l0\"", "\"bf%.\\t%l0\"", "8", "0", "0", "\"b%s%ss\\t%LLF%d\\n\"", "\"f\"", "\"t\"", "\"/\"", "\".\"", "\"\\tnop\\n\"", "\"bra\\t%l0\"", "\"\\tnop\\n\"", "\"LF\"", "\"\"", "4", "10", "\"b%s%ss\\t%%l0\"", "\"t\"", "\"f\"", "\"/\"", "\".\"", "0", "\"nop\"" ]

[]

[ "<s>", "inline", "bool", "isFPImm", "(", "const", "APFloat", "&", "Val", ")", "{", "uint32_t", "Imm8", ";", "return", "isFPImm", "(", "Val", ",", "Imm8", ")", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "void", "cris_asm_output_mi_thunk", "(", "FILE", "*", "stream", ",", "tree", "thunkdecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "funcdecl", ")", "{", "final_start_function", "(", "emit_barrier", "(", ")", ",", "stream", ",", "1", ")", ";", "if", "(", "delta", ">", "0", ")", "fprintf", "(", "stream", ",", "\"\\tadd%s \"", "HOST_WIDE_INT_PRINT_DEC", "\",$%s\\n\"", ",", "ADDITIVE_SIZE_MODIFIER", "(", "delta", ")", ",", "delta", ",", "reg_names", "[", "CRIS_FIRST_ARG_REG", "]", ")", ";", "else", "if", "(", "delta", "<", "0", ")", "fprintf", "(", "stream", ",", "\"\\tsub%s \"", "HOST_WIDE_INT_PRINT_DEC", "\",$%s\\n\"", ",", "ADDITIVE_SIZE_MODIFIER", "(", "-", "delta", ")", ",", "-", "delta", ",", "reg_names", "[", "CRIS_FIRST_ARG_REG", "]", ")", ";", "if", "(", "flag_pic", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "funcdecl", ")", ",", "0", ")", ",", "0", ")", ";", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "if", "(", "TARGET_V32", ")", "{", "fprintf", "(", "stream", ",", "\"\\tba \"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"%s\\n\\tnop\\n\"", ",", "CRIS_PLT_PCOFFSET_SUFFIX", ")", ";", "}", "else", "{", "fprintf", "(", "stream", ",", "\"\\tadd.d \"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"%s,$pc\\n\"", ",", "CRIS_PLT_PCOFFSET_SUFFIX", ")", ";", "}", "}", "else", "{", "fprintf", "(", "stream", ",", "\"\\tjump \"", ")", ";", "assemble_name", "(", "stream", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "funcdecl", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "if", "(", "TARGET_V32", ")", "fprintf", "(", "stream", ",", "\"\\tnop\\n\"", ")", ";", "}", "final_end_function", "(", ")", ";", "}", "</s>" ]

[ "The", "ASM_OUTPUT_MI_THUNK", "worker", "." ]

[ "cris", "1", "0", "\"\\tadd%s \"", "\",$%s\\n\"", "0", "\"\\tsub%s \"", "\",$%s\\n\"", "0", "0", "\"\\tba \"", "\"%s\\n\\tnop\\n\"", "\"\\tadd.d \"", "\"%s,$pc\\n\"", "\"\\tjump \"", "0", "0", "\"\\n\"", "\"\\tnop\\n\"" ]

[]

[ "<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "diff", "=", "t", ",", "t", "=", "f", ",", "f", "=", "diff", ";", "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_MULT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "diff", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "." ]

[ "alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "assert", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "if", "(", "TM", "->", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "unsigned", "PC", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "PC", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "else", "PC", "=", "TII", "->", "getGlobalBaseReg", "(", "&", "MF", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOVPC32r", ")", ",", "PC", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "{", "unsigned", "GlobalBaseReg", "=", "TII", "->", "getGlobalBaseReg", "(", "&", "MF", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "ADD32ri", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "PC", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86::GR32RegisterClass", "X86::MOVPC32r", "0", "X86", "X86::ADD32ri", "\"_GLOBAL_OFFSET_TABLE_\"", "X86II::MO_GOT_ABSOLUTE_ADDRESS" ]

[]

[ "<s>", "void", "emit_fusion_load_store", "(", "rtx", "load_store_reg", ",", "rtx", "addis_reg", ",", "rtx", "offset", ",", "const", "char", "*", "insn_str", ")", "{", "rtx", "fuse_ops", "[", "10", "]", ";", "char", "insn_template", "[", "80", "]", ";", "fuse_ops", "[", "0", "]", "=", "load_store_reg", ";", "fuse_ops", "[", "1", "]", "=", "addis_reg", ";", "if", "(", "CONST_INT_P", "(", "offset", ")", "&&", "satisfies_constraint_I", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "UNSPEC", "&&", "XINT", "(", "offset", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "offset", ",", "0", ",", "0", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "offset", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "offset", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TOCREL", "&&", "CONST_INT_P", "(", "XEXP", "(", "offset", ",", "1", ")", ")", ")", "{", "rtx", "tocrel_unspec", "=", "XEXP", "(", "offset", ",", "0", ")", ";", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "tocrel_unspec", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "3", "]", "=", "XEXP", "(", "offset", ",", "1", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", "&&", "CONSTANT_P", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "fatal_insn", "(", "\"Unable to generate load/store offset for fusion\"", ",", "offset", ")", ";", "return", ";", "}", "</s>" ]

[ "Emit", "a", "D-form", "load", "or", "store", "instruction", "that", "is", "the", "second", "instruction", "of", "a", "fusion", "sequence", "." ]

[ "rs6000", "10", "80", "0", "1", "\"%s %%0,%%2(%%1)\"", "2", "1", "\"%s %%0,%%2@toc@l(%%1)\"", "\"%s %%0,%%2@l(%%1)\"", "2", "0", "0", "0", "0", "1", "1", "0", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", "\"%s %%0,%%2+%%3@l(%%1)\"", "2", "0", "0", "3", "1", "\"%s %%0,%%2@l(%%1)\"", "2", "\"Unable to generate load/store offset for fusion\"" ]

[]

[ "<s>", "const", "char", "*", "output_reload_insisf", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ",", "int", "*", "len", ")", "{", "rtx", "src", "=", "operands", "[", "1", "]", ";", "int", "cnst", "=", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", ";", "if", "(", "len", ")", "{", "if", "(", "cnst", ")", "*", "len", "=", "4", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff00", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff0000", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff000000", ")", "!=", "0", ")", ";", "else", "*", "len", "=", "8", ";", "return", "\"\"", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "A0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "lo8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "A0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff00", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "B0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hi8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "B0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff0000", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "C0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hlo8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "C0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff000000", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "D0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hhi8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "D0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Reload", "a", "SI", "or", "SF", "compile", "time", "constant", "OP", "[", "1", "]", "into", "the", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "LEN", "==", "NULL", ":", "Output", "instructions", ".", "LEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "LEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "." ]

[ "avr", "1", "4", "0xff", "0", "0xff00", "0", "0xff0000", "0", "0xff000000", "0", "8", "\"\"", "0xff", "0", "2", "1", "2", "0xff00", "0", "2", "1", "2", "0xff0000", "0", "2", "1", "2", "0xff000000", "0", "2", "1", "2", "\"\"" ]

[]

[ "<s>", "void", "crx_expand_epilogue", "(", "void", ")", "{", "rtx", "return_reg", ";", "int", "only_popret_RA", "=", "(", "save_regs", "[", "RETURN_ADDRESS_REGNUM", "]", "&&", "(", "sum_regs", "==", "UNITS_PER_WORD", ")", ")", ";", "return_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDRESS_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_move_insn", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ";", "if", "(", "size_for_adjusting_sp", ">", "0", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size_for_adjusting_sp", ")", ")", ")", ";", "if", "(", "crx_interrupt_function_p", "(", ")", ")", "emit_jump_insn", "(", "gen_interrupt_return", "(", ")", ")", ";", "else", "if", "(", "last_reg_to_save", "==", "-", "1", ")", "emit_jump_insn", "(", "gen_indirect_jump_return", "(", ")", ")", ";", "else", "if", "(", "only_popret_RA", ")", "emit_jump_insn", "(", "gen_popret_RA_return", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_pop_and_popret_return", "(", "GEN_INT", "(", "sum_regs", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "insn", "that", "updates", "the", "stack", "for", "local", "variables", "and", "padding", "for", "*", "registers", "we", "save", ".", "-", "Generate", "the", "appropriate", "return", "insn", "." ]

[ "crx", "0", "1" ]

[]

[ "<s>", "static", "void", "c6x_compute_frame_layout", "(", "struct", "c6x_frame", "*", "frame", ")", "{", "HOST_WIDE_INT", "size", "=", "get_frame_size", "(", ")", ";", "HOST_WIDE_INT", "offset", ";", "int", "nregs", ";", "offset", "=", "-", "4", ";", "frame", "->", "padding0", "=", "0", ";", "nregs", "=", "c6x_nsaved_regs", "(", ")", ";", "frame", "->", "push_rts", "=", "false", ";", "frame", "->", "b3_offset", "=", "0", ";", "if", "(", "use_push_rts_p", "(", "nregs", ")", ")", "{", "frame", "->", "push_rts", "=", "true", ";", "frame", "->", "b3_offset", "=", "(", "TARGET_BIG_ENDIAN", "?", "-", "12", ":", "-", "13", ")", "*", "4", ";", "nregs", "=", "14", ";", "}", "else", "if", "(", "c6x_save_reg", "(", "REG_B3", ")", ")", "{", "int", "idx", ";", "for", "(", "idx", "=", "N_SAVE_ORDER", "-", "1", ";", "reg_save_order", "[", "idx", "]", "!=", "REG_B3", ";", "idx", "--", ")", "{", "if", "(", "c6x_save_reg", "(", "reg_save_order", "[", "idx", "]", ")", ")", "frame", "->", "b3_offset", "-=", "4", ";", "}", "}", "frame", "->", "nregs", "=", "nregs", ";", "if", "(", "size", "==", "0", "&&", "nregs", "==", "0", ")", "{", "frame", "->", "padding0", "=", "4", ";", "frame", "->", "padding1", "=", "frame", "->", "padding2", "=", "0", ";", "frame", "->", "frame_pointer_offset", "=", "frame", "->", "to_allocate", "=", "0", ";", "frame", "->", "outgoing_arguments_size", "=", "0", ";", "return", ";", "}", "if", "(", "!", "frame", "->", "push_rts", ")", "offset", "+=", "frame", "->", "nregs", "*", "4", ";", "if", "(", "offset", "==", "0", "&&", "size", "==", "0", "&&", "crtl", "->", "outgoing_args_size", "==", "0", "&&", "!", "crtl", "->", "is_leaf", ")", "frame", "->", "padding0", "=", "frame", "->", "padding1", "=", "4", ";", "else", "if", "(", "offset", "&", "4", ")", "frame", "->", "padding1", "=", "4", ";", "else", "frame", "->", "padding1", "=", "0", ";", "offset", "+=", "frame", "->", "padding0", "+", "frame", "->", "padding1", ";", "frame", "->", "frame_pointer_offset", "=", "offset", ";", "offset", "+=", "size", ";", "frame", "->", "outgoing_arguments_size", "=", "crtl", "->", "outgoing_args_size", ";", "offset", "+=", "frame", "->", "outgoing_arguments_size", ";", "if", "(", "(", "offset", "&", "4", ")", "==", "0", ")", "frame", "->", "padding2", "=", "8", ";", "else", "frame", "->", "padding2", "=", "4", ";", "frame", "->", "to_allocate", "=", "offset", "+", "frame", "->", "padding2", ";", "}", "</s>" ]

[ "Compute", "the", "layout", "of", "the", "stack", "frame", "and", "store", "it", "in", "FRAME", "." ]

[ "c6x", "4", "0", "0", "12", "13", "4", "14", "1", "4", "0", "0", "4", "0", "0", "0", "4", "0", "0", "0", "4", "4", "4", "0", "4", "0", "8", "4" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDR", ":", "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", "::", "t2LDRi12", ":", "case", "ARM", "::", "tRestore", ":", "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", "::", "FLDD", ":", "case", "ARM", "::", "FLDS", ":", "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", ";", "}", "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::LDR", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::t2LDRi12", "ARM::tRestore", "1", "2", "2", "0", "1", "0", "ARM::FLDD", "ARM::FLDS", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", "::", "MC_PATTERN", ">", "&", "Patterns", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "if", "(", "!", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ")", "return", "false", ";", "bool", "Commute", ";", "if", "(", "isReassocCandidate", "(", "Root", ",", "Commute", ")", ")", "{", "if", "(", "Commute", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_YB", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_YB", ")", ";", "}", "else", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_BY", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_BY", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "vms_c_register_includes", "(", "const", "char", "*", "sysroot", ",", "const", "char", "*", "iprefix", "ATTRIBUTE_UNUSED", ",", "int", "stdinc", ")", "{", "static", "const", "char", "dir_separator_str", "[", "]", "=", "{", "DIR_SEPARATOR", ",", "0", "}", ";", "struct", "cpp_dir", "*", "dir", ";", "if", "(", "!", "stdinc", ")", "return", ";", "for", "(", "dir", "=", "get_added_cpp_dirs", "(", "INC_SYSTEM", ")", ";", "dir", "!=", "NULL", ";", "dir", "=", "dir", "->", "next", ")", "{", "const", "char", "*", "const", "*", "lib", ";", "for", "(", "lib", "=", "vms_std_modules", ";", "*", "lib", "!=", "NULL", ";", "lib", "++", ")", "{", "char", "*", "path", ";", "struct", "stat", "st", ";", "if", "(", "sysroot", "!=", "NULL", ")", "path", "=", "concat", "(", "sysroot", ",", "dir", "->", "name", ",", "dir_separator_str", ",", "*", "lib", ",", "NULL", ")", ";", "else", "path", "=", "concat", "(", "dir", "->", "name", ",", "dir_separator_str", ",", "*", "lib", ",", "NULL", ")", ";", "if", "(", "stat", "(", "path", ",", "&", "st", ")", "==", "0", "&&", "S_ISDIR", "(", "st", ".", "st_mode", ")", ")", "{", "cpp_dir", "*", "p", ";", "p", "=", "XNEW", "(", "cpp_dir", ")", ";", "p", "->", "next", "=", "NULL", ";", "p", "->", "name", "=", "path", ";", "p", "->", "sysp", "=", "1", ";", "p", "->", "construct", "=", "vms_construct_include_filename", ";", "p", "->", "user_supplied_p", "=", "0", ";", "add_cpp_dir_path", "(", "p", ",", "INC_SYSTEM", ")", ";", "}", "else", "free", "(", "path", ")", ";", "}", "}", "}", "</s>" ]

[ "Find", "include", "modules", "in", "the", "include", "path", "." ]

[ "vms", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "int64_t", "RVVStackSize", ";", "Align", "RVVStackAlign", ";", "std", "::", "tie", "(", "RVVStackSize", ",", "RVVStackAlign", ")", "=", "assignRVVStackObjectOffsets", "(", "MFI", ")", ";", "RVFI", "->", "setRVVStackSize", "(", "RVVStackSize", ")", ";", "RVFI", "->", "setRVVStackAlign", "(", "RVVStackAlign", ")", ";", "MFI", ".", "ensureMaxAlignment", "(", "RVVStackAlign", ")", ";", "const", "RISCVInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", "||", "hasRVVSpillWithFIs", "(", "MF", ",", "TII", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "if", "(", "RVVStackSize", "!=", "0", ")", "{", "int", "RVVRegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RVVRegScavFI", ")", ";", "}", "}", "if", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "||", "RVFI", "->", "useSaveRestoreLibCalls", "(", "MF", ")", ")", "{", "RVFI", "->", "setCalleeSavedStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Size", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", "{", "int", "FrameIdx", "=", "Info", ".", "getFrameIdx", "(", ")", ";", "if", "(", "MFI", ".", "getStackID", "(", "FrameIdx", ")", "!=", "TargetStackID", "::", "Default", ")", "continue", ";", "Size", "+=", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ";", "}", "RVFI", "->", "setCalleeSavedStackSize", "(", "Size", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV", "RISCV", "RISCV", "11", "0", "0", "0" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MSP430TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MSP430", "::", "GR8RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MSP430", "::", "GR16RegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "MSP430", "MSP430", "1", "0", "MVT::i8", "0U", "MSP430::GR8RegClass", "0U", "MSP430::GR16RegClass" ]

[]

[ "<s>", "static", "rtx", "get_jump_target", "(", "rtx", "branch", ")", "{", "if", "(", "CALL_P", "(", "branch", ")", ")", "{", "rtx", "call", ";", "call", "=", "PATTERN", "(", "branch", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "PARALLEL", ")", "call", "=", "XVECEXP", "(", "call", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "CALL", ")", "return", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "rtx", "for", "the", "jump", "target", "." ]

[ "tilepro", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "mips_signed_immediate_p", "(", "unsigned", "HOST_WIDE_INT", "x", ",", "int", "bits", ",", "int", "shift", "=", "0", ")", "{", "x", "+=", "1", "<<", "(", "bits", "+", "shift", "-", "1", ")", ";", "return", "mips_unsigned_immediate_p", "(", "x", ",", "bits", ",", "shift", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "fits", "within", "a", "signed", "field", "of", "BITS", "bits", "that", "is", "shifted", "left", "SHIFT", "bits", "before", "being", "used", "." ]

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

[]

[ "<s>", "unsigned", "WebAssemblyRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "unsigned", "Regs", "[", "2", "]", "[", "2", "]", "=", "{", "{", "WebAssembly", "::", "SP32", ",", "WebAssembly", "::", "SP64", "}", ",", "{", "WebAssembly", "::", "FP32", ",", "WebAssembly", "::", "FP64", "}", "}", ";", "const", "WebAssemblyFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "Regs", "[", "TFI", "->", "hasFP", "(", "MF", ")", "]", "[", "TT", ".", "isArch64Bit", "(", ")", "]", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "WebAssembly", "WebAssembly", "2", "2", "WebAssembly::SP32", "WebAssembly::SP64", "WebAssembly::FP32", "WebAssembly::FP64", "WebAssembly" ]

[]

[ "<s>", "PLTEntryBase", "*", "MipsPLT", "::", "create", "(", ")", "{", "return", "new", "MipsPLTA", "(", "*", "m_pSectionData", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Integer", "||", "Kind", "==", "Symbol", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "Cpu0AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".gpword\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"" ]

[]

[ "<s>", "static", "bool", "th_mempair_operand_p", "(", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "MEM_SIZE_KNOWN_P", "(", "mem", ")", ")", "return", "false", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", ";", "auto", "mem_sz", "=", "MEM_SIZE", "(", "mem", ")", ";", "auto", "mode_sz", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "!", "known_eq", "(", "mem_sz", ",", "mode_sz", ")", ")", "return", "false", ";", "machine_mode", "mem_mode", "=", "GET_MODE", "(", "mem", ")", ";", "unsigned", "shamt", "=", "(", "mem_mode", "==", "DImode", ")", "?", "4", ":", "3", ";", "rtx", "base", ";", "HOST_WIDE_INT", "offset", ";", "split_plus", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "HOST_WIDE_INT", "imm2", "=", "offset", ">>", "shamt", ";", "if", "(", "imm2", "<", "0", "||", "imm2", ">=", "4", ")", "return", "false", ";", "if", "(", "(", "imm2", "<<", "shamt", ")", "!=", "offset", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "the", "given", "MEM", "can", "be", "used", "to", "define", "the", "address", "of", "a", "mempair", "instruction", "." ]

[ "riscv", "4", "3", "0", "0", "4" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "genAlternativeCodeSequence", "(", "MachineInstr", "&", "Root", ",", "MachineCombinerPattern", "Pattern", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "InsInstrs", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DelInstrs", ",", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "InstrIdxForVirtReg", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "case", "MachineCombinerPattern", "::", "REASSOC_XY_AMM_BMM", ":", "case", "MachineCombinerPattern", "::", "REASSOC_XMM_AMM_BMM", ":", "case", "MachineCombinerPattern", "::", "REASSOC_XY_BCA", ":", "case", "MachineCombinerPattern", "::", "REASSOC_XY_BAC", ":", "reassociateFMA", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "default", ":", "TargetInstrInfo", "::", "genAlternativeCodeSequence", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "When", "getMachineCombinerPatterns", "(", ")", "finds", "potential", "patterns", ",", "this", "function", "generates", "the", "instructions", "that", "could", "replace", "the", "original", "code", "sequence", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "bool", "ix86_class_likely_spilled_p", "(", "reg_class_t", "rclass", ")", "{", "switch", "(", "rclass", ")", "{", "case", "AREG", ":", "case", "DREG", ":", "case", "CREG", ":", "case", "BREG", ":", "case", "AD_REGS", ":", "case", "SIREG", ":", "case", "DIREG", ":", "case", "SSE_FIRST_REG", ":", "case", "FP_TOP_REG", ":", "case", "FP_SECOND_REG", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CLASS_LIKELY_SPILLED_P", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetAndroid", "(", ")", "||", "Subtarget", "->", "isTargetFuchsia", "(", ")", ")", "return", "TargetLowering", "::", "useLoadStackGuardNode", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "rename_single_chain", "(", "du_head_p", "head", ",", "HARD_REG_SET", "*", "unavailable", ")", "{", "int", "best_new_reg", ";", "int", "n_uses", "=", "0", ";", "struct", "du_chain", "*", "tmp", ";", "int", "reg", "=", "head", "->", "regno", ";", "enum", "reg_class", "super_class", "=", "NO_REGS", ";", "if", "(", "head", "->", "cannot_rename", ")", "return", "false", ";", "if", "(", "fixed_regs", "[", "reg", "]", "||", "global_regs", "[", "reg", "]", "||", "(", "frame_pointer_needed", "&&", "reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", "return", "false", ";", "for", "(", "tmp", "=", "head", "->", "first", ";", "tmp", ";", "tmp", "=", "tmp", "->", "next_use", ")", "{", "if", "(", "DEBUG_INSN_P", "(", "tmp", "->", "insn", ")", ")", "continue", ";", "n_uses", "++", ";", "IOR_COMPL_HARD_REG_SET", "(", "*", "unavailable", ",", "reg_class_contents", "[", "tmp", "->", "cl", "]", ")", ";", "super_class", "=", "reg_class_superunion", "[", "(", "int", ")", "super_class", "]", "[", "(", "int", ")", "tmp", "->", "cl", "]", ";", "}", "if", "(", "n_uses", "<", "1", ")", "return", "false", ";", "best_new_reg", "=", "find_rename_reg", "(", "head", ",", "super_class", ",", "unavailable", ",", "reg", ",", "false", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"Register %s in insn %d\"", ",", "reg_names", "[", "reg", "]", ",", "INSN_UID", "(", "head", "->", "first", "->", "insn", ")", ")", ";", "if", "(", "head", "->", "need_caller_save_reg", ")", "fprintf", "(", "dump_file", ",", "\" crosses a call\"", ")", ";", "}", "if", "(", "best_new_reg", "==", "reg", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"; no available better choice\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "regrename_do_replace", "(", "head", ",", "best_new_reg", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\", renamed as %s\\n\"", ",", "reg_names", "[", "best_new_reg", "]", ")", ";", "df_set_regs_ever_live", "(", "best_new_reg", ",", "true", ")", ";", "}", "else", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\", renaming as %s failed\\n\"", ",", "reg_names", "[", "best_new_reg", "]", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Rename", "the", "register", "HEAD-", ">", "regno", "in", "all", "the", "insns", "in", "the", "chain", "HEAD", "to", "any", "register", "not", "in", "the", "set", "UNAVAILABLE", ".", "Adapted", "from", "rename_chains", "in", "regrename.c", "." ]

[ "aarch64", "0", "1", "\"Register %s in insn %d\"", "\" crosses a call\"", "\"; no available better choice\\n\"", "\", renamed as %s\\n\"", "\", renaming as %s failed\\n\"" ]

[]

[ "<s>", "static", "bool", "arm_block_set_unaligned_vect", "(", "rtx", "dstbase", ",", "unsigned", "HOST_WIDE_INT", "length", ",", "unsigned", "HOST_WIDE_INT", "value", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "unsigned", "int", "i", ",", "j", ",", "nelt_v16", ",", "nelt_v8", ",", "nelt_mode", ";", "rtx", "dst", ",", "mem", ";", "rtx", "val_elt", ",", "val_vec", ",", "reg", ";", "rtx", "rval", "[", "MAX_VECT_LEN", "]", ";", "rtx", "(", "*", "gen_func", ")", "(", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "unsigned", "HOST_WIDE_INT", "v", "=", "value", ";", "gcc_assert", "(", "(", "align", "&", "0x3", ")", "!=", "0", ")", ";", "nelt_v8", "=", "GET_MODE_NUNITS", "(", "V8QImode", ")", ";", "nelt_v16", "=", "GET_MODE_NUNITS", "(", "V16QImode", ")", ";", "if", "(", "length", ">=", "nelt_v16", ")", "{", "mode", "=", "V16QImode", ";", "gen_func", "=", "gen_movmisalignv16qi", ";", "}", "else", "{", "mode", "=", "V8QImode", ";", "gen_func", "=", "gen_movmisalignv8qi", ";", "}", "nelt_mode", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "gcc_assert", "(", "length", ">=", "nelt_mode", ")", ";", "if", "(", "!", "arm_block_set_vect_profit_p", "(", "length", ",", "align", ",", "mode", ")", ")", "return", "false", ";", "dst", "=", "copy_addr_to_reg", "(", "XEXP", "(", "dstbase", ",", "0", ")", ")", ";", "mem", "=", "adjust_automodify_address", "(", "dstbase", ",", "mode", ",", "dst", ",", "0", ")", ";", "v", "=", "sext_hwi", "(", "v", ",", "BITS_PER_WORD", ")", ";", "val_elt", "=", "GEN_INT", "(", "v", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "nelt_mode", ";", "j", "++", ")", "rval", "[", "j", "]", "=", "val_elt", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "val_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "gen_rtvec_v", "(", "nelt_mode", ",", "rval", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "val_vec", ")", ";", "for", "(", "i", "=", "0", ";", "(", "i", "+", "nelt_mode", "<=", "length", ")", ";", "i", "+=", "nelt_mode", ")", "{", "emit_insn", "(", "(", "*", "gen_func", ")", "(", "mem", ",", "reg", ")", ")", ";", "if", "(", "i", "+", "2", "*", "nelt_mode", "<=", "length", ")", "emit_insn", "(", "gen_add2_insn", "(", "dst", ",", "GEN_INT", "(", "nelt_mode", ")", ")", ")", ";", "}", "gcc_assert", "(", "(", "i", "+", "nelt_v8", ")", ">", "length", "||", "mode", "==", "V16QImode", ")", ";", "if", "(", "i", "+", "nelt_v8", "<", "length", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "dst", ",", "GEN_INT", "(", "length", "-", "i", ")", ")", ")", ";", "if", "(", "(", "length", "&", "1", ")", "!=", "0", "&&", "align", ">=", "2", ")", "set_mem_align", "(", "mem", ",", "BITS_PER_UNIT", ")", ";", "emit_insn", "(", "gen_movmisalignv16qi", "(", "mem", ",", "reg", ")", ")", ";", "}", "else", "if", "(", "i", "<", "length", "&&", "i", "+", "nelt_v8", ">=", "length", ")", "{", "if", "(", "mode", "==", "V16QImode", ")", "{", "reg", "=", "gen_lowpart", "(", "V8QImode", ",", "reg", ")", ";", "mem", "=", "adjust_automodify_address", "(", "dstbase", ",", "V8QImode", ",", "dst", ",", "0", ")", ";", "}", "emit_insn", "(", "gen_add2_insn", "(", "dst", ",", "GEN_INT", "(", "(", "length", "-", "i", ")", "+", "(", "nelt_mode", "-", "nelt_v8", ")", ")", ")", ")", ";", "if", "(", "(", "length", "&", "1", ")", "!=", "0", "&&", "align", ">=", "2", ")", "set_mem_align", "(", "mem", ",", "BITS_PER_UNIT", ")", ";", "emit_insn", "(", "gen_movmisalignv8qi", "(", "mem", ",", "reg", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Set", "a", "block", "of", "memory", "using", "vectorization", "instructions", "for", "the", "unaligned", "case", ".", "We", "fill", "the", "first", "LENGTH", "bytes", "of", "the", "memory", "area", "starting", "from", "DSTBASE", "with", "byte", "constant", "VALUE", ".", "ALIGN", "is", "the", "alignment", "requirement", "of", "memory", ".", "Return", "TRUE", "if", "succeeded", "." ]

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

[]

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "Subtarget", ".", "inMips16Mode", "(", ")", "?", "0", ":", "&", "InstrItins", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "parse_env_var", "(", "const", "char", "*", "str", ",", "char", "*", "*", "*", "pvalues", ")", "{", "const", "char", "*", "curval", ",", "*", "nextval", ";", "char", "*", "*", "values", ";", "unsigned", "num", "=", "1", ",", "i", ";", "curval", "=", "strchr", "(", "str", ",", "':'", ")", ";", "while", "(", "curval", ")", "{", "num", "++", ";", "curval", "=", "strchr", "(", "curval", "+", "1", ",", "':'", ")", ";", "}", "values", "=", "(", "char", "*", "*", ")", "xmalloc", "(", "num", "*", "sizeof", "(", "char", "*", ")", ")", ";", "curval", "=", "str", ";", "nextval", "=", "strchr", "(", "curval", ",", "':'", ")", ";", "if", "(", "nextval", "==", "NULL", ")", "nextval", "=", "strchr", "(", "curval", ",", "'\\0'", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num", ";", "i", "++", ")", "{", "int", "l", "=", "nextval", "-", "curval", ";", "values", "[", "i", "]", "=", "(", "char", "*", ")", "xmalloc", "(", "l", "+", "1", ")", ";", "memcpy", "(", "values", "[", "i", "]", ",", "curval", ",", "l", ")", ";", "values", "[", "i", "]", "[", "l", "]", "=", "0", ";", "curval", "=", "nextval", "+", "1", ";", "nextval", "=", "strchr", "(", "curval", ",", "':'", ")", ";", "if", "(", "nextval", "==", "NULL", ")", "nextval", "=", "strchr", "(", "curval", ",", "'\\0'", ")", ";", "}", "*", "pvalues", "=", "values", ";", "return", "num", ";", "}", "</s>" ]

[ "Parse", "STR", ",", "saving", "found", "tokens", "into", "PVALUES", "and", "return", "their", "number", ".", "Tokens", "are", "assumed", "to", "be", "delimited", "by", "'", ":", "'", "." ]

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

[]

[ "<s>", "unsigned", "RISCVAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "RISCVOperand", "&", "Op", "=", "static_cast", "<", "RISCVOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "bool", "IsRegFPR32", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR32RegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "bool", "IsRegFPR32C", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR32CRegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "if", "(", "(", "IsRegFPR32", "&&", "Kind", "==", "MCK_FPR64", ")", "||", "(", "IsRegFPR32C", "&&", "Kind", "==", "MCK_FPR64C", ")", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR32ToFPR64", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::FPR32RegClassID", "RISCV", "RISCV::FPR32CRegClassID" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Single-Path Scheduler (machine code)\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Scheduler (machine code)\"" ]

[]

[ "<s>", "const", "MCFixup", "*", "RISCVMCExpr", "::", "getPCRelHiFixup", "(", "const", "MCFragment", "*", "*", "DFOut", ")", "const", "{", "MCValue", "AUIPCLoc", ";", "if", "(", "!", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "AUIPCLoc", ",", "nullptr", ",", "nullptr", ")", ")", "return", "nullptr", ";", "const", "MCSymbolRefExpr", "*", "AUIPCSRE", "=", "AUIPCLoc", ".", "getSymA", "(", ")", ";", "if", "(", "!", "AUIPCSRE", ")", "return", "nullptr", ";", "const", "MCSymbol", "*", "AUIPCSymbol", "=", "&", "AUIPCSRE", "->", "getSymbol", "(", ")", ";", "const", "auto", "*", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "AUIPCSymbol", "->", "getFragment", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "uint64_t", "Offset", "=", "AUIPCSymbol", "->", "getOffset", "(", ")", ";", "if", "(", "DF", "->", "getContents", "(", ")", ".", "size", "(", ")", "==", "Offset", ")", "{", "DF", "=", "dyn_cast_or_null", "<", "MCDataFragment", ">", "(", "DF", "->", "getNextNode", "(", ")", ")", ";", "if", "(", "!", "DF", ")", "return", "nullptr", ";", "Offset", "=", "0", ";", "}", "for", "(", "const", "MCFixup", "&", "F", ":", "DF", "->", "getFixups", "(", ")", ")", "{", "if", "(", "F", ".", "getOffset", "(", ")", "!=", "Offset", ")", "continue", ";", "switch", "(", "(", "unsigned", ")", "F", ".", "getKind", "(", ")", ")", "{", "default", ":", "continue", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "case", "RISCV", "::", "fixup_riscv_pcrel_hi20", ":", "case", "RISCV", "::", "fixup_riscv_captab_pcrel_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_ie_captab_pcrel_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_captab_pcrel_hi20", ":", "if", "(", "DFOut", ")", "*", "DFOut", "=", "DF", ";", "return", "&", "F", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Get", "the", "corresponding", "PC-relative", "HI", "fixup", "that", "a", "VK_RISCV_PCREL_LO", "points", "to", ",", "and", "optionally", "the", "fragment", "containing", "it", "." ]

[ "RISCV", "RISCV", "0", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::fixup_riscv_pcrel_hi20", "RISCV::fixup_riscv_captab_pcrel_hi20", "RISCV::fixup_riscv_tls_ie_captab_pcrel_hi20", "RISCV::fixup_riscv_tls_gd_captab_pcrel_hi20" ]

[]

[ "<s>", "static", "bool", "sh_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "SPECIAL_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPUL_REG", ")", "return", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ";", "if", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "mode", "==", "SFmode", ")", "return", "true", ";", "if", "(", "mode", "==", "V2SFmode", ")", "{", "if", "(", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "2", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V4SFmode", ")", "{", "if", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "4", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V16SFmode", ")", "return", "regno", "==", "FIRST_XD_REG", ";", "if", "(", "FP_REGISTER_P", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", "||", "(", "(", "TARGET_SH2E", ")", "&&", "mode", "==", "SCmode", ")", "||", "(", "(", "(", "TARGET_FPU_DOUBLE", "&&", "mode", "==", "DFmode", ")", "||", "mode", "==", "DCmode", ")", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "1", ")", "==", "0", ")", "||", "(", "TARGET_SH4", "&&", "mode", "==", "TImode", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "3", ")", "==", "0", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "XD_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "DFmode", ";", "if", "(", "regno", "==", "PR_REG", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPSCR_REG", ")", "return", "mode", "==", "SImode", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "We", "can", "allow", "any", "mode", "in", "any", "general", "register", ".", "The", "special", "registers", "only", "allow", "SImode", ".", "Do", "n't", "allow", "any", "mode", "in", "the", "PR", ".", "We", "can", "not", "hold", "DCmode", "values", "in", "the", "XD", "registers", "because", "alter_reg", "handles", "subregs", "of", "them", "incorrectly", ".", "We", "could", "work", "around", "this", "by", "spacing", "the", "XD", "registers", "like", "the", "DR", "registers", ",", "but", "this", "would", "require", "additional", "memory", "in", "every", "compilation", "to", "hold", "larger", "register", "vectors", ".", "We", "could", "hold", "SFmode", "/", "SCmode", "values", "in", "XD", "registers", ",", "but", "that", "would", "require", "a", "tertiary", "reload", "when", "reloading", "from", "/", "to", "memory", ",", "and", "a", "secondary", "reload", "to", "reload", "from", "/", "to", "general", "regs", ";", "that", "seems", "to", "be", "a", "losing", "proposition", ".", "We", "want", "to", "allow", "TImode", "FP", "regs", "so", "that", "when", "V4SFmode", "is", "loaded", "as", "TImode", ",", "it", "wo", "n't", "be", "ferried", "through", "GP", "registers", "first", "." ]

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

[]

[ "<s>", "bool", "empty", "(", ")", "{", "return", "(", "!", "HaveConst", "&&", "Q", ".", "empty", "(", ")", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "SystemZCopyPhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "F", ".", "getRegInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "Modified", "|=", "visitMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "bool", "hasLiveCondCodeDef", "(", "MachineInstr", "*", "MI", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "!", "MO", ".", "isDead", "(", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "XCoreSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "uint64_t", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", ".", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "XCore", "XCore", "XCore", "XCore", "0", "0", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "static", "void", "aarch64_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gr_saved", ",", "vr_saved", ";", "local_cum", "=", "*", "cum", ";", "aarch64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "gr_saved", "=", "NUM_ARG_REGS", "-", "local_cum", ".", "aapcs_ncrn", ";", "vr_saved", "=", "NUM_FP_ARG_REGS", "-", "local_cum", ".", "aapcs_nvrn", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")", "{", "if", "(", "local_cum", ".", "aapcs_nvrn", ">", "0", ")", "sorry", "(", "\"%qs and floating point or vector arguments\"", ",", "\"-mgeneral-regs-only\"", ")", ";", "vr_saved", "=", "0", ";", "}", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gr_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "gr_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "aapcs_ncrn", "+", "R0_REGNUM", ",", "mem", ",", "gr_saved", ")", ";", "}", "if", "(", "vr_saved", ">", "0", ")", "{", "machine_mode", "mode", "=", "TImode", ";", "int", "off", ",", "i", ";", "off", "=", "-", "AARCH64_ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "off", "-=", "vr_saved", "*", "UNITS_PER_VREG", ";", "for", "(", "i", "=", "local_cum", ".", "aapcs_nvrn", ";", "i", "<", "NUM_FP_ARG_REGS", ";", "++", "i", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "aarch64_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "V0_REGNUM", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_VREG", ";", "}", "}", "}", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", "=", "(", "AARCH64_ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "+", "vr_saved", "*", "UNITS_PER_VREG", ")", ";", "}", "</s>" ]

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

[ "aarch64", "0", "\"%qs and floating point or vector arguments\"", "\"-mgeneral-regs-only\"", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMOptimizeBarriersPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "ToRemove", ";", "int64_t", "DMBType", "=", "-", "1", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "IsRemovableNextDMB", "=", "false", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "DMB", ")", "{", "if", "(", "IsRemovableNextDMB", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "DMBType", ")", "{", "ToRemove", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "{", "IsRemovableNextDMB", "=", "true", ";", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "if", "(", "!", "CanMovePastDMB", "(", "&", "MI", ")", ")", "{", "IsRemovableNextDMB", "=", "false", ";", "}", "}", "}", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "MI", ":", "ToRemove", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumDMBsRemoved", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "ARM::DMB", "0", "0", "0" ]

[]

[ "<s>", "bool", "ix86_expand_pextr", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "unsigned", "int", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "unsigned", "int", "pos", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "SUBREG_P", "(", "dst", ")", ")", "{", "if", "(", "SUBREG_BYTE", "(", "dst", ")", ">", "0", ")", "return", "false", ";", "dst", "=", "SUBREG_REG", "(", "dst", ")", ";", "}", "if", "(", "SUBREG_P", "(", "src", ")", ")", "{", "pos", "+=", "SUBREG_BYTE", "(", "src", ")", "*", "BITS_PER_UNIT", ";", "src", "=", "SUBREG_REG", "(", "src", ")", ";", "}", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "V16QImode", ":", "case", "V8HImode", ":", "case", "V4SImode", ":", "case", "V2DImode", ":", "case", "V1TImode", ":", "case", "TImode", ":", "{", "machine_mode", "srcmode", ",", "dstmode", ";", "rtx", "d", ",", "pat", ";", "dstmode", "=", "mode_for_size", "(", "size", ",", "MODE_INT", ",", "0", ")", ";", "switch", "(", "dstmode", ")", "{", "case", "QImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V16QImode", ";", "break", ";", "case", "HImode", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "false", ";", "srcmode", "=", "V8HImode", ";", "break", ";", "case", "SImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V4SImode", ";", "break", ";", "case", "DImode", ":", "gcc_assert", "(", "TARGET_64BIT", ")", ";", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V2DImode", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "pos", "&", "(", "size", "-", "1", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "dst", ")", "==", "dstmode", ")", "d", "=", "dst", ";", "else", "d", "=", "gen_reg_rtx", "(", "dstmode", ")", ";", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "GEN_INT", "(", "pos", "/", "size", ")", ")", ")", ";", "pat", "=", "gen_rtx_VEC_SELECT", "(", "dstmode", ",", "gen_lowpart", "(", "srcmode", ",", "src", ")", ",", "pat", ")", ";", "if", "(", "dstmode", "==", "QImode", "||", "dstmode", "==", "HImode", ")", "{", "pat", "=", "gen_rtx_ZERO_EXTEND", "(", "SImode", ",", "pat", ")", ";", "d", "=", "gen_lowpart", "(", "SImode", ",", "d", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "d", ",", "pat", ")", ")", ";", "if", "(", "d", "!=", "dst", ")", "emit_move_insn", "(", "dst", ",", "gen_lowpart", "(", "GET_MODE", "(", "dst", ")", ",", "d", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Expand", "an", "extract", "from", "a", "vector", "register", "through", "pextr", "insn", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "0", "1", "2", "3", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "DP", "<<", "\"unsupported \"", "<<", "getDescription", "(", ")", "<<", "\" in \"", "<<", "Fn", ".", "getName", "(", ")", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "\"unsupported \"", "\" in \"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerAsmOutputForConstraint", "(", "SDValue", "&", "Chain", ",", "SDValue", "&", "Flag", ",", "SDLoc", "DL", ",", "const", "AsmOperandInfo", "&", "OpInfo", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "X86", "::", "CondCode", "Cond", "=", "parseConstraintCode", "(", "OpInfo", ".", "ConstraintCode", ")", ";", "if", "(", "Cond", "==", "X86", "::", "COND_INVALID", ")", "return", "SDValue", "(", ")", ";", "if", "(", "OpInfo", ".", "ConstraintVT", ".", "isVector", "(", ")", "||", "!", "OpInfo", ".", "ConstraintVT", ".", "isInteger", "(", ")", "||", "OpInfo", ".", "ConstraintVT", ".", "getSizeInBits", "(", ")", "<", "8", ")", "report_fatal_error", "(", "\"Flag output operand is of invalid type\"", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "Flag", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "X86", "::", "EFLAGS", ",", "MVT", "::", "i32", ",", "Flag", ")", ";", "Chain", "=", "Flag", ".", "getValue", "(", "1", ")", ";", "}", "else", "Flag", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "X86", "::", "EFLAGS", ",", "MVT", "::", "i32", ")", ";", "SDValue", "CC", "=", "getSETCC", "(", "Cond", ",", "Flag", ",", "DL", ",", "DAG", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "OpInfo", ".", "ConstraintVT", ",", "CC", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Handle", "Lowering", "flag", "assembly", "outputs", "." ]

[ "X86", "X86", "X86::CondCode", "X86::COND_INVALID", "8", "\"Flag output operand is of invalid type\"", "X86::EFLAGS", "MVT::i32", "1", "X86::EFLAGS", "MVT::i32", "ISD::ZERO_EXTEND" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createHexagonRemoveExtendOps", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "getHexagonTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALLReg", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoTAIL", ")", "{", "expandFunctionCall", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "2", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoAddTPRel", ")", "{", "expandAddTPRel", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "1", ";", "return", ";", "}", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "2", ":", "{", "uint16_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "case", "4", ":", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "2", "RISCV::PseudoAddTPRel", "1", "\"Unhandled encodeInstruction length!\"", "2", "support::endian", "support::little", "4", "support::endian", "support::little" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Windows 32-bit x86 EH state insertion\"", ";", "}", "</s>" ]

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

[ "X86", "\"Windows 32-bit x86 EH state insertion\"" ]

[]

[ "<s>", "MachineOperand", "&", "pop", "(", ")", "{", "RangeTy", "&", "Range", "=", "Worklist", ".", "back", "(", ")", ";", "MachineOperand", "&", "Op", "=", "*", "Range", ".", "begin", "(", ")", ";", "Range", "=", "drop_begin", "(", "Range", ")", ";", "if", "(", "Range", ".", "empty", "(", ")", ")", "Worklist", ".", "pop_back", "(", ")", ";", "assert", "(", "(", "Worklist", ".", "empty", "(", ")", "||", "!", "Worklist", ".", "back", "(", ")", ".", "empty", "(", ")", ")", "&&", "\"Empty ranges shouldn't remain in the worklist\"", ")", ";", "return", "Op", ";", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "WebAssembly", "\"Empty ranges shouldn't remain in the worklist\"" ]

[]

[ "<s>", "static", "bool", "arm_asm_elf_flags_numeric", "(", "unsigned", "int", "flags", ",", "unsigned", "int", "*", "num", ")", "{", "if", "(", "flags", "&", "SECTION_ARM_PURECODE", ")", "{", "*", "num", "=", "0x20000000", ";", "if", "(", "!", "(", "flags", "&", "SECTION_DEBUG", ")", ")", "*", "num", "|=", "0x2", ";", "if", "(", "flags", "&", "SECTION_EXCLUDE", ")", "*", "num", "|=", "0x80000000", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "*", "num", "|=", "0x1", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "*", "num", "|=", "0x4", ";", "if", "(", "flags", "&", "SECTION_MERGE", ")", "*", "num", "|=", "0x10", ";", "if", "(", "flags", "&", "SECTION_STRINGS", ")", "*", "num", "|=", "0x20", ";", "if", "(", "flags", "&", "SECTION_TLS", ")", "*", "num", "|=", "0x400", ";", "if", "(", "HAVE_COMDAT_GROUP", "&&", "(", "flags", "&", "SECTION_LINKONCE", ")", ")", "*", "num", "|=", "0x200", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_ASM_ELF_FLAGS_NUMERIC", "hook", ".", "For", "pure-code", "sections", "there", "is", "no", "letter", "code", "for", "this", "attribute", ",", "so", "output", "all", "the", "section", "flags", "numerically", "when", "this", "is", "needed", "." ]

[ "arm", "0x20000000", "0x2", "0x80000000", "0x1", "0x4", "0x10", "0x20", "0x400", "0x200" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "createAArch64BranchRelaxation", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "F2003fInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "F2003f", "::", "KRZrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003f::KRZrr" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Teak", "0" ]

[]

[ "<s>", "const", "uint16_t", "*", "LM32RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "LM32", "::", "R11", ",", "LM32", "::", "R12", ",", "LM32", "::", "R13", ",", "LM32", "::", "R14", ",", "LM32", "::", "R15", ",", "LM32", "::", "R16", ",", "LM32", "::", "R17", ",", "LM32", "::", "R18", ",", "LM32", "::", "R19", ",", "LM32", "::", "R20", ",", "LM32", "::", "R21", ",", "LM32", "::", "R22", ",", "LM32", "::", "R23", ",", "LM32", "::", "R24", ",", "LM32", "::", "R25", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "LM32", "LM32", "LM32::R11", "LM32::R12", "LM32::R13", "LM32::R14", "LM32::R15", "LM32::R16", "LM32::R17", "LM32::R18", "LM32::R19", "LM32::R20", "LM32::R21", "LM32::R22", "LM32::R23", "LM32::R24", "LM32::R25", "0" ]

[]

[ "<s>", "SDValue", "HexagonSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "AlwaysInline", "||", "(", "Align", "&", "0x3", ")", "!=", "0", "||", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "SizeVal", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "SizeVal", "<", "32", "||", "(", "SizeVal", "%", "8", ")", "!=", "0", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "SpecialMemcpyName", "=", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getTargetExternalSymbol", "(", "SpecialMemcpyName", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "Hexagon", "Hexagon", "0x3", "0", "32", "8", "0", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", "||", "L", "->", "getNumBlocks", "(", ")", "!=", "1", ")", "return", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "BasicBlock", "*", "BB", "=", "L", "->", "getLoopLatch", "(", ")", ";", "if", "(", "BB", "->", "getParent", "(", ")", "->", "optForSize", "(", ")", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "1", "0", "0", "0", "4", "4", "12" ]

[]

[ "<s>", "Register", "RISCVRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "TFI", "->", "getFPReg", "(", ")", ":", "TFI", "->", "getSPReg", "(", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vtbl", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "MAX_VECT_LEN", "]", ",", "sel", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "unsigned", "int", "i", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "vmode", "!=", "V8QImode", "&&", "vmode", "!=", "V16QImode", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "rperm", "[", "i", "]", "=", "GEN_INT", "(", "d", "->", "perm", "[", "i", "]", ")", ";", "sel", "=", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "gen_rtvec_v", "(", "nelt", ",", "rperm", ")", ")", ";", "sel", "=", "force_reg", "(", "vmode", ",", "sel", ")", ";", "arm_expand_vec_perm_1", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "sel", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "NEON", "VTBL", "instruction", "is", "a", "fully", "variable", "permuation", "that", "'s", "even", "stronger", "than", "what", "we", "expose", "via", "VEC_PERM_EXPR", ".", "What", "it", "does", "n't", "do", "is", "mask", "the", "index", "operand", "as", "VEC_PERM_EXPR", "requires", ".", "Therefore", "we", "can", "do", "slightly", "better", "by", "expanding", "this", "as", "a", "constant", "where", "we", "do", "n't", "have", "to", "apply", "a", "mask", "." ]

[ "arm", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", ")", "return", "new", "PPCDispatchGroupSBHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "DIR_440", "&&", "Directive", "!=", "PPC", "::", "DIR_A2", "&&", "Directive", "!=", "PPC", "::", "DIR_E500mc", "&&", "Directive", "!=", "PPC", "::", "DIR_E5500", ")", "{", "assert", "(", "DAG", "->", "TII", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "DAG", ")", ";", "}", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "\"No InstrInfo?\"", "PPC" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Local Dynamic TLS Access Clean-up\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"Local Dynamic TLS Access Clean-up\"" ]

[]

[ "<s>", "void", "SPIRVPassConfig", "::", "addISelPrepare", "(", ")", "{", "addPass", "(", "createSPIRVEmitIntrinsicsPass", "(", "&", "getTM", "<", "SPIRVTargetMachine", ">", "(", ")", ")", ")", ";", "TargetPassConfig", "::", "addISelPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "in", "preparation", "for", "instruction", "selection", "." ]

[ "SPIRV", "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "{", "unsigned", "MaxIntSize", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "MaxIntSize", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_hard_regno_mode_ok", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "regno", "==", "CC_REGNUM", ";", "if", "(", "regno", "==", "VG_REGNUM", ")", "return", "mode", "==", "DImode", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "&", "VEC_SVE_PRED", ")", "return", "pr_or_ffr_regnum_p", "(", "regno", ")", ";", "if", "(", "pr_or_ffr_regnum_p", "(", "regno", ")", ")", "return", "false", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "ptr_mode", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "mode", "==", "Pmode", ";", "if", "(", "GP_REGNUM_P", "(", "regno", ")", ")", "{", "if", "(", "vec_flags", "&", "VEC_ANY_SVE", ")", "return", "false", ";", "if", "(", "known_le", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "8", ")", ")", "return", "true", ";", "if", "(", "known_le", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "16", ")", ")", "return", "(", "regno", "&", "1", ")", "==", "0", ";", "}", "else", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "{", "if", "(", "vec_flags", "&", "VEC_STRUCT", ")", "return", "end_hard_regno", "(", "mode", ",", "regno", ")", "-", "1", "<=", "V31_REGNUM", ";", "else", "return", "!", "VECTOR_MODE_P", "(", "mode", ")", "||", "vec_flags", "!=", "0", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_MODE_OK", "." ]

[ "aarch64", "8", "16", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "int", "cris_initial_frame_pointer_offset", "(", "void", ")", "{", "int", "regno", ";", "int", "offs", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "cris_reg_saved_in_regsave_area", "(", "regno", ")", ")", "offs", "+=", "4", ";", "offs", "+=", "get_frame_size", "(", ")", ";", "offs", "+=", "crtl", "->", "outgoing_args_size", ";", "if", "(", "TARGET_STACK_ALIGN", ")", "offs", "=", "TARGET_ALIGN_BY_32", "?", "(", "offs", "+", "3", ")", "&", "~", "3", ":", "(", "offs", "+", "1", ")", "&", "~", "1", ";", "return", "offs", ";", "}", "</s>" ]

[ "This", "used", "to", "be", "the", "INITIAL_FRAME_POINTER_OFFSET", "worker", ";", "now", "only", "handles", "FP", "-", ">", "SP", "elimination", "offset", "." ]

[ "cris", "0", "0", "4", "3", "3", "1", "1" ]

[]

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

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

[ "Tile64" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "const", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", ".", "CreateFixedObject", "(", "4", ",", "-", "8", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "isPPC64", "?", "PPC", "::", "X31", ":", "PPC", "::", "R31", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "RegInfo", "->", "getBaseRegister", "(", "MF", ")", ")", ";", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "SavedRegs", ".", "reset", "(", "PPC", "::", "R30", ")", ";", "int", "TCSPDelta", "=", "0", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "1", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "const", "uint64_t", "SpillSize", "=", "4", ";", "const", "int64_t", "SpillOffset", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "8", ":", "Subtarget", ".", "isAIXABI", "(", ")", "?", "4", ":", "-", "4", ";", "int", "FrameIdx", "=", "MFI", ".", "CreateFixedObject", "(", "SpillSize", ",", "SpillOffset", ",", "true", ",", "false", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "PPC", "8", "4", "4", "8", "PPC", "PPC::X31", "PPC::R31", "PPC::R30", "0", "0", "1", "PPC::CR2", "PPC::CR3", "PPC::CR4", "4", "PPC", "8", "4", "4" ]

[]

[ "<s>", "void", "ARM64FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "ARM64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "ARM64RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "ARM64RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "NumRestores", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "LastPopI", "=", "MBBI", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "if", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "{", "++", "NumRestores", ";", "--", "LastPopI", ";", "}", "while", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", "{", "++", "LastPopI", ";", "--", "NumRestores", ";", "}", "}", "NumBytes", "-=", "NumRestores", "*", "16", ";", "assert", "(", "NumBytes", ">=", "0", "&&", "\"Negative stack allocation size!?\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "!", "canUseRedZone", "(", "MF", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "ARM64", "::", "SP", ",", "ARM64", "::", "SP", ",", "NumBytes", ",", "TII", ")", ";", "return", ";", "}", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "ARM64", "::", "SP", ",", "ARM64", "::", "FP", ",", "-", "(", "NumRestores", "-", "1", ")", "*", "16", ",", "TII", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "ARM64", "ARM64", "\"Can only insert epilog into returning blocks\"", "ARM64", "ARM64", "ARM64", "ARM64", "0", "16", "0", "\"Negative stack allocation size!?\"", "ARM64::SP", "ARM64::SP", "ARM64::SP", "ARM64::FP", "1", "16" ]

[]

[ "<s>", "bool", "WebAssemblyFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "HasFixedSizedObjects", "=", "MFI", ".", "getStackSize", "(", ")", ">", "0", ";", "bool", "NeedsFixedReference", "=", "!", "hasBP", "(", "MF", ")", "||", "HasFixedSizedObjects", ";", "return", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "NeedsFixedReference", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0" ]

[]

[ "<s>", "void", "mips_split_64bit_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", ")", "{", "emit_insn", "(", "gen_load_df_low", "(", "copy_rtx", "(", "dest", ")", ",", "mips_subword", "(", "src", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_load_df_high", "(", "dest", ",", "mips_subword", "(", "src", ",", "1", ")", ",", "copy_rtx", "(", "dest", ")", ")", ")", ";", "}", "else", "if", "(", "FP_REG_RTX_P", "(", "src", ")", ")", "{", "emit_move_insn", "(", "mips_subword", "(", "dest", ",", "0", ")", ",", "mips_subword", "(", "src", ",", "0", ")", ")", ";", "emit_insn", "(", "gen_store_df_high", "(", "mips_subword", "(", "dest", ",", "1", ")", ",", "src", ")", ")", ";", "}", "else", "{", "rtx", "low_dest", ";", "low_dest", "=", "mips_subword", "(", "dest", ",", "0", ")", ";", "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{", "emit_move_insn", "(", "mips_subword", "(", "dest", ",", "1", ")", ",", "mips_subword", "(", "src", ",", "1", ")", ")", ";", "emit_move_insn", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "0", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "0", ")", ")", ";", "emit_move_insn", "(", "mips_subword", "(", "dest", ",", "1", ")", ",", "mips_subword", "(", "src", ",", "1", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "a", "64-bit", "move", "from", "SRC", "to", "DEST", "assuming", "that", "mips_split_64bit_move_p", "holds", ".", "Moves", "into", "and", "out", "of", "FPRs", "cause", "some", "difficulty", "here", ".", "Such", "moves", "will", "always", "be", "DFmode", ",", "since", "paired", "FPRs", "are", "not", "allowed", "to", "store", "DImode", "values", ".", "The", "most", "natural", "representation", "would", "be", "two", "separate", "32-bit", "moves", ",", "such", "as", ":", "(", "set", "(", "reg", ":", "SI", "$", "f0", ")", "(", "mem", ":", "SI", "...", ")", ")", "(", "set", "(", "reg", ":", "SI", "$", "f1", ")", "(", "mem", ":", "SI", "...", ")", ")", "However", ",", "the", "second", "insn", "is", "invalid", "because", "odd-numbered", "FPRs", "are", "not", "allowed", "to", "store", "independent", "values", ".", "Use", "the", "patterns", "load_df_low", ",", "load_df_high", "and", "store_df_high", "instead", "." ]

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "bool", "ClobbersEFLAGS", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Orig", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "{", "ClobbersEFLAGS", "=", "true", ";", "break", ";", "}", "}", "if", "(", "ClobbersEFLAGS", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "int", "Value", ";", "switch", "(", "Orig", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "Value", "=", "0", ";", "break", ";", "case", "X86", "::", "MOV32r1", ":", "Value", "=", "1", ";", "break", ";", "case", "X86", "::", "MOV32r_1", ":", "Value", "=", "-", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "Orig", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "addOperand", "(", "Orig", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "MachineInstr", "&", "NewMI", "=", "*", "std", "::", "prev", "(", "I", ")", ";", "NewMI", ".", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::MOV32r0", "0", "X86::MOV32r1", "1", "X86::MOV32r_1", "1", "\"Unexpected instruction!\"", "X86::MOV32ri", "0", "0" ]

[]

[ "<s>", "static", "int", "hi_const", "(", "rtx", "src", ")", "{", "return", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src", ")", ">=", "-", "32768", "&&", "INTVAL", "(", "src", ")", "<=", "32767", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "constant", "would", "be", "an", "ok", "source", "for", "a", "mov.w", "instead", "of", "a", "mov.l", "." ]

[ "sh", "32768", "32767" ]

[]

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

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

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "static", "bool", "aarch64_optab_supported_p", "(", "int", "op", ",", "machine_mode", "mode1", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "rsqrt_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "use_rsqrt_p", "(", "mode1", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr128", ":", "SPU", "::", "STQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr16", ":", "SPU", "::", "STQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr8", ":", "SPU", "::", "STQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "STQDv16i8", ":", "SPU", "::", "STQXv16i8", ";", "}", "else", "{", "assert", "(", "0", "&&", "\"Unknown regclass!\"", ")", ";", "abort", "(", ")", ";", "}", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::STQDr128", "SPU::STQXr128", "SPU::R64CRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R64FPRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R32CRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R32FPRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R16CRegisterClass", "SPU::STQDr16", "SPU::STQXr16", "SPU::R8CRegisterClass", "SPU::STQDr8", "SPU::STQXr8", "SPU::VECREGRegisterClass", "SPU::STQDv16i8", "SPU::STQXv16i8", "0", "\"Unknown regclass!\"" ]

[]

[ "<s>", "unsigned", "getFlatAddressSpace", "(", ")", "const", "{", "if", "(", "IsGraphicsShader", ")", "return", "-", "1", ";", "return", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "}", "</s>" ]

[ "Returns", "the", "address", "space", "ID", "for", "a", "target", "'s", "'flat", "'", "address", "space", "." ]

[ "AMDGPU", "1", "AMDGPU" ]

[]

[ "<s>", "int", "xstormy16_interrupt_function_p", "(", ")", "{", "tree", "attributes", ";", "if", "(", "!", "cfun", ")", "return", "0", ";", "attributes", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "return", "lookup_attribute", "(", "\"interrupt\"", ",", "attributes", ")", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "function", "is", "an", "interrupt", "function", "." ]

[ "stormy16", "0", "\"interrupt\"" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "TII", "->", "reserveIndirectRegisters", "(", "Reserved", ",", "MF", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

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

[]

[ "<s>", "static", "inline", "ChildIteratorType", "child_begin", "(", "NodeType", "*", "N", ")", "{", "return", "N", "->", "Sites", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "nodes_iterator/begin/end", "-", "Allow", "iteration", "over", "all", "nodes", "in", "the", "graph" ]

[ "Patmos" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAddr64", "(", ")", ")", "report_fatal_error", "(", "\"64-bit WebAssembly (wasm64) is not currently supported\"", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"********** ISelDAGToDAG **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"64-bit WebAssembly (wasm64) is not currently supported\"" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateMem", "(", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "auto", "Res", "=", "llvm", "::", "make_unique", "<", "X86Operand", ">", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "unsigned", "AArch64RegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "A", ",", "const", "RegisterBank", "&", "B", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "&", "A", "==", "&", "AArch64", "::", "GPRRegBank", "&&", "&", "B", "==", "&", "AArch64", "::", "FPRRegBank", ")", "return", "5", ";", "if", "(", "&", "A", "==", "&", "AArch64", "::", "FPRRegBank", "&&", "&", "B", "==", "&", "AArch64", "::", "GPRRegBank", ")", "return", "4", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "A", ",", "B", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AArch64", "AArch64", "AArch64::GPRRegBank", "AArch64::FPRRegBank", "5", "AArch64::FPRRegBank", "AArch64::GPRRegBank", "4" ]

[]

[ "<s>", "static", "void", "nios2_option_override", "(", "void", ")", "{", "unsigned", "int", "i", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_LINUX_ABI", ")", "sorry", "(", "\"position-independent code requires the Linux ABI\"", ")", ";", "if", "(", "flag_pic", "&&", "stack_limit_rtx", "&&", "GET_CODE", "(", "stack_limit_rtx", ")", "==", "SYMBOL_REF", ")", "sorry", "(", "\"PIC support for -fstack-limit-symbol\"", ")", ";", "init_machine_status", "=", "&", "nios2_init_machine_status", ";", "nios2_section_threshold", "=", "(", "global_options_set", ".", "x_g_switch_value", "?", "g_switch_value", ":", "NIOS2_DEFAULT_GVALUE", ")", ";", "if", "(", "nios2_gpopt_option", "==", "gpopt_unspecified", ")", "{", "if", "(", "flag_pic", ")", "nios2_gpopt_option", "=", "gpopt_none", ";", "else", "nios2_gpopt_option", "=", "gpopt_local", ";", "}", "if", "(", "flag_pic", ")", "{", "if", "(", "nios2_gpopt_option", "!=", "gpopt_none", ")", "error", "(", "\"-mgpopt not supported with PIC.\"", ")", ";", "if", "(", "nios2_gprel_sec", ")", "error", "(", "\"-mgprel-sec= not supported with PIC.\"", ")", ";", "if", "(", "nios2_r0rel_sec", ")", "error", "(", "\"-mr0rel-sec= not supported with PIC.\"", ")", ";", "}", "if", "(", "nios2_gprel_sec", ")", "{", "if", "(", "regcomp", "(", "&", "nios2_gprel_sec_regex", ",", "nios2_gprel_sec", ",", "REG_EXTENDED", "|", "REG_NOSUB", ")", ")", "error", "(", "\"-mgprel-sec= argument is not a valid regular expression.\"", ")", ";", "}", "if", "(", "nios2_r0rel_sec", ")", "{", "if", "(", "regcomp", "(", "&", "nios2_r0rel_sec_regex", ",", "nios2_r0rel_sec", ",", "REG_EXTENDED", "|", "REG_NOSUB", ")", ")", "error", "(", "\"-mr0rel-sec= argument is not a valid regular expression.\"", ")", ";", "}", "if", "(", "!", "TARGET_HAS_MUL", "&&", "TARGET_HAS_MULX", ")", "target_flags", "&=", "~", "MASK_HAS_MULX", ";", "if", "(", "!", "TARGET_ARCH_R2", ")", "{", "if", "(", "TARGET_HAS_BMX", ")", "error", "(", "\"BMX instructions are only supported with R2 architecture\"", ")", ";", "if", "(", "TARGET_HAS_CDX", ")", "error", "(", "\"CDX instructions are only supported with R2 architecture\"", ")", ";", "}", "if", "(", "TARGET_ARCH_R2", "&&", "TARGET_BIG_ENDIAN", ")", "error", "(", "\"R2 architecture is little-endian only\"", ")", ";", "nios2_init_fpu_configs", "(", ")", ";", "if", "(", "nios2_custom_fpu_cfg_string", "&&", "*", "nios2_custom_fpu_cfg_string", ")", "nios2_handle_custom_fpu_cfg", "(", "nios2_custom_fpu_cfg_string", ",", "NULL", ",", "false", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "i", "++", ")", "nios2_handle_custom_fpu_insn_option", "(", "i", ")", ";", "nios2_custom_check_insns", "(", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "nios2", "\"position-independent code requires the Linux ABI\"", "\"PIC support for -fstack-limit-symbol\"", "\"-mgpopt not supported with PIC.\"", "\"-mgprel-sec= not supported with PIC.\"", "\"-mr0rel-sec= not supported with PIC.\"", "\"-mgprel-sec= argument is not a valid regular expression.\"", "\"-mr0rel-sec= argument is not a valid regular expression.\"", "\"BMX instructions are only supported with R2 architecture\"", "\"CDX instructions are only supported with R2 architecture\"", "\"R2 architecture is little-endian only\"", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Fixup SetCC\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Fixup SetCC\"" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"" ]

[]

[ "<s>", "static", "bool", "interesting_frame_related_regno", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "0", ")", "return", "true", ";", "if", "(", "regno", "==", "CR2_REGNO", ")", "return", "true", ";", "return", "save_reg_p", "(", "regno", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "when", "rs6000_frame_related", "is", "processing", "SETs", "within", "a", "PARALLEL", ",", "and", "returns", "whether", "the", "REGNO", "save", "ought", "to", "be", "marked", "RTX_FRAME_RELATED_P", ".", "The", "PARALLELs", "involved", "are", "those", "for", "out-of-line", "register", "save", "functions", ",", "store", "multiple", ",", "and", "the", "Darwin", "world_save", ".", "They", "may", "contain", "registers", "that", "do", "n't", "really", "need", "saving", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "static", "bool", "avr_set_core_architecture", "(", "void", ")", "{", "if", "(", "!", "avr_mmcu", ")", "avr_mmcu", "=", "AVR_MMCU_DEFAULT", ";", "avr_arch", "=", "&", "avr_arch_types", "[", "0", "]", ";", "for", "(", "const", "avr_mcu_t", "*", "mcu", "=", "avr_mcu_types", ";", ";", "mcu", "++", ")", "{", "if", "(", "NULL", "==", "mcu", "->", "name", ")", "{", "error", "(", "\"unknown core architecture %qs specified with %qs\"", ",", "avr_mmcu", ",", "\"-mmcu=\"", ")", ";", "avr_inform_core_architectures", "(", ")", ";", "break", ";", "}", "else", "if", "(", "0", "==", "strcmp", "(", "mcu", "->", "name", ",", "avr_mmcu", ")", "&&", "NULL", "==", "mcu", "->", "macro", ")", "{", "avr_arch", "=", "&", "avr_arch_types", "[", "mcu", "->", "arch_id", "]", ";", "if", "(", "avr_n_flash", "<", "0", ")", "avr_n_flash", "=", "mcu", "->", "n_flash", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Set", "`", "avr_arch", "'", "as", "specified", "by", "`", "-mmcu=", "'", ".", "Return", "true", "on", "success", "." ]

[ "avr", "0", "\"unknown core architecture %qs specified with %qs\"", "\"-mmcu=\"", "0", "0" ]

[]

[ "<s>", "bool", "nds32_gw_ex_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "return", "nds32_n10_ex_to_ex_p", "(", "producer", ",", "consumer", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "EX", "to", "EX", "(", "ADDR_OUT", "-", ">", "ADDR_IN", ")", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_MOV_B32_e64" ]

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "aarch64_emit_call_insn", "(", "rtx", "pat", ")", "{", "rtx", "insn", "=", "emit_call_insn", "(", "pat", ")", ";", "rtx", "*", "fusage", "=", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "clobber_reg", "(", "fusage", ",", "gen_rtx_REG", "(", "word_mode", ",", "IP0_REGNUM", ")", ")", ";", "clobber_reg", "(", "fusage", ",", "gen_rtx_REG", "(", "word_mode", ",", "IP1_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Emit", "call", "insn", "with", "PAT", "and", "do", "aarch64-specific", "handling", "." ]

[ "aarch64" ]

[]