Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "CodeGenOpt", "::", "Level", "OptLevel", "=", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "STI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "PerformSHLCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "UREM", ":", "case", "ISD", "::", "SREM", ":", "return", "PerformREMCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::FADD", "ISD::MUL", "ISD::SHL", "ISD::AND", "ISD::UREM", "ISD::SREM", "ISD::SETCC" ]

[]

[ "<s>", "static", "void", "get_scratch_register_on_entry", "(", "struct", "scratch_reg", "*", "sr", ")", "{", "int", "regno", ";", "sr", "->", "saved", "=", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "regno", "=", "R11_REG", ";", "}", "else", "{", "tree", "decl", "=", "current_function_decl", ",", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "bool", "fastcall_p", "=", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "!=", "NULL_TREE", ";", "bool", "thiscall_p", "=", "lookup_attribute", "(", "\"thiscall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "!=", "NULL_TREE", ";", "bool", "static_chain_p", "=", "DECL_STATIC_CHAIN", "(", "decl", ")", ";", "int", "regparm", "=", "ix86_function_regparm", "(", "fntype", ",", "decl", ")", ";", "int", "drap_regno", "=", "crtl", "->", "drap_reg", "?", "REGNO", "(", "crtl", "->", "drap_reg", ")", ":", "INVALID_REGNUM", ";", "if", "(", "(", "regparm", "<", "1", "||", "(", "fastcall_p", "&&", "!", "static_chain_p", ")", ")", "&&", "drap_regno", "!=", "AX_REG", ")", "regno", "=", "AX_REG", ";", "else", "if", "(", "thiscall_p", "&&", "!", "static_chain_p", "&&", "drap_regno", "!=", "AX_REG", ")", "regno", "=", "AX_REG", ";", "else", "if", "(", "regparm", "<", "2", "&&", "!", "thiscall_p", "&&", "drap_regno", "!=", "DX_REG", ")", "regno", "=", "DX_REG", ";", "else", "if", "(", "regparm", "<", "3", "&&", "!", "fastcall_p", "&&", "!", "thiscall_p", "&&", "!", "static_chain_p", "&&", "drap_regno", "!=", "CX_REG", ")", "regno", "=", "CX_REG", ";", "else", "if", "(", "ix86_save_reg", "(", "BX_REG", ",", "true", ")", ")", "regno", "=", "BX_REG", ";", "else", "if", "(", "!", "(", "regparm", "==", "3", "&&", "static_chain_p", ")", "&&", "ix86_save_reg", "(", "SI_REG", ",", "true", ")", ")", "regno", "=", "SI_REG", ";", "else", "if", "(", "ix86_save_reg", "(", "DI_REG", ",", "true", ")", ")", "regno", "=", "DI_REG", ";", "else", "{", "regno", "=", "(", "drap_regno", "==", "AX_REG", "?", "DX_REG", ":", "AX_REG", ")", ";", "sr", "->", "saved", "=", "true", ";", "}", "}", "sr", "->", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "if", "(", "sr", "->", "saved", ")", "{", "rtx", "insn", "=", "emit_insn", "(", "gen_push", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Return", "a", "short-lived", "scratch", "register", "for", "use", "on", "function", "entry", ".", "In", "32-bit", "mode", ",", "it", "is", "valid", "only", "after", "the", "registers", "are", "saved", "in", "the", "prologue", ".", "This", "register", "must", "be", "released", "by", "means", "of", "release_scratch_register_on_entry", "once", "it", "is", "dead", "." ]

[ "i386", "\"fastcall\"", "\"thiscall\"", "1", "2", "3", "3", "1" ]

[]

[ "<s>", "void", "rs6000_aix_emit_builtin_unwind_init", "(", ")", "{", "rtx", "mem", ";", "rtx", "stack_top", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "opcode_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "insn_after_throw", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "hard_frame_pointer_rtx", ")", ";", "emit_move_insn", "(", "stack_top", ",", "mem", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_top", ",", "GEN_INT", "(", "2", "*", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ")", ")", ";", "emit_move_insn", "(", "opcode_addr", ",", "mem", ")", ";", "emit_move_insn", "(", "insn_after_throw", ",", "gen_rtx_MEM", "(", "SImode", ",", "opcode_addr", ")", ")", ";", "}", "</s>" ]

[ "If", "_Unwind_", "*", "has", "been", "called", "from", "within", "the", "same", "module", ",", "toc", "register", "is", "not", "guaranteed", "to", "be", "saved", "to", "40", "(", "1", ")", "on", "function", "entry", ".", "Save", "it", "there", "in", "that", "case", "." ]

[ "rs6000", "2" ]

[]

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

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "InternalInstruction", "internalInstr", ";", "dlog_t", "loggerFn", "=", "logger", ";", "if", "(", "&", "vStream", "==", "&", "nulls", "(", ")", ")", "loggerFn", "=", "0", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "void", "*", ")", "&", "region", ",", "loggerFn", ",", "(", "void", "*", ")", "&", "vStream", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "Fail", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "return", "(", "!", "translateInstruction", "(", "instr", ",", "internalInstr", ")", ")", "?", "Success", ":", "Fail", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "SHUXI" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", ",", "const", "MCSubtargetInfo", "&", ",", "MCInst", "&", ")", "const", "override", "{", "}", "</s>" ]

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

[ "Lanai" ]

[]

[ "<s>", "bool", "TPCInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Alias", ",", "unsigned", "OpNo0", ",", "unsigned", "OpNo1", ")", "{", "OS", "<<", "\"\\t\"", "<<", "Alias", "<<", "\" \"", ";", "printOperand", "(", "MI", ",", "OpNo0", ",", "OS", ")", ";", "OS", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo1", ",", "OS", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "TPC", "TPC", "\"\\t\"", "\" \"", "\", \"" ]

[]

[ "<s>", "bool", "isLegalMaskedScatter", "(", "Type", "*", "Ty", ",", "MaybeAlign", "Alignment", ")", "{", "return", "isLegalMaskedGather", "(", "Ty", ",", "Alignment", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "static", "void", "frv_finish_packet", "(", "void", "(", "*", "handle_packet", ")", "(", "void", ")", ")", "{", "if", "(", "frv_packet", ".", "num_insns", ">", "0", ")", "{", "handle_packet", "(", ")", ";", "state_transition", "(", "frv_packet", ".", "dfa_state", ",", "0", ")", ";", "frv_start_packet", "(", ")", ";", "}", "}", "</s>" ]

[ "Finish", "the", "current", "packet", ",", "if", "any", ",", "and", "start", "a", "new", "one", ".", "Call", "HANDLE_PACKET", "with", "FRV_PACKET", "describing", "the", "completed", "packet", "." ]

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

[]

[ "<s>", "bool", "sparc_expand_conditional_move", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "rc", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "machine_mode", "cmp_mode", ";", "rtx", "cc_reg", ",", "dst", ",", "cmp", ";", "cmp", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "DImode", "&&", "!", "TARGET_ARCH64", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "TFmode", "&&", "!", "TARGET_HARD_QUAD", ")", "cmp", "=", "sparc_emit_float_lib_cmp", "(", "XEXP", "(", "cmp", ",", "0", ")", ",", "XEXP", "(", "cmp", ",", "1", ")", ",", "rc", ")", ";", "cmp_mode", "=", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", ";", "rc", "=", "GET_CODE", "(", "cmp", ")", ";", "dst", "=", "operands", "[", "0", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "2", "]", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "dst", ")", ")", "{", "if", "(", "reg_overlap_mentioned_p", "(", "dst", ",", "cmp", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "dst", ",", "operands", "[", "3", "]", ")", ";", "}", "else", "if", "(", "operands", "[", "2", "]", "==", "dst", ")", "{", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", ";", "if", "(", "GET_MODE_CLASS", "(", "cmp_mode", ")", "==", "MODE_FLOAT", ")", "rc", "=", "reverse_condition_maybe_unordered", "(", "rc", ")", ";", "else", "rc", "=", "reverse_condition", "(", "rc", ")", ";", "}", "if", "(", "XEXP", "(", "cmp", ",", "1", ")", "==", "const0_rtx", "&&", "GET_CODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "REG", "&&", "cmp_mode", "==", "DImode", "&&", "v9_regcmp_p", "(", "rc", ")", ")", "cc_reg", "=", "XEXP", "(", "cmp", ",", "0", ")", ";", "else", "cc_reg", "=", "gen_compare_reg_1", "(", "rc", ",", "XEXP", "(", "cmp", ",", "0", ")", ",", "XEXP", "(", "cmp", ",", "1", ")", ")", ";", "cmp", "=", "gen_rtx_fmt_ee", "(", "rc", ",", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cmp", ",", "operands", "[", "2", "]", ",", "dst", ")", ")", ")", ";", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "code", "to", "conditionally", "move", "either", "OPERANDS", "[", "2", "]", "or", "OPERANDS", "[", "3", "]", "into", "OPERANDS", "[", "0", "]", "in", "MODE", ".", "OPERANDS", "[", "1", "]", "is", "the", "operator", "of", "the", "condition", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_emit_bic", "(", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "s1", ",", "rtx", "s2", ",", "int", "shift", ")", "{", "rtx", "shift_rtx", "=", "GEN_INT", "(", "shift", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "gen", "=", "gen_and_one_cmpl_lshrsi3", ";", "break", ";", "case", "E_DImode", ":", "gen", "=", "gen_and_one_cmpl_lshrdi3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "s2", ",", "shift_rtx", ",", "s1", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "BIC", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "enum", "aarch_parse_opt_result", "aarch_parse_branch_protection", "(", "const", "char", "*", "const_str", ",", "char", "*", "*", "last_str", ")", "{", "char", "*", "str_root", "=", "xstrdup", "(", "const_str", ")", ";", "char", "*", "token_save", "=", "NULL", ";", "char", "*", "str", "=", "strtok_r", "(", "str_root", ",", "\"+\"", ",", "&", "token_save", ")", ";", "enum", "aarch_parse_opt_result", "res", "=", "AARCH_PARSE_OK", ";", "if", "(", "!", "str", ")", "res", "=", "AARCH_PARSE_MISSING_ARG", ";", "else", "{", "char", "*", "next_str", "=", "strtok_r", "(", "NULL", ",", "\"+\"", ",", "&", "token_save", ")", ";", "aarch_handle_no_branch_protection", "(", "NULL", ",", "NULL", ")", ";", "while", "(", "str", "&&", "res", "==", "AARCH_PARSE_OK", ")", "{", "const", "aarch_branch_protect_type", "*", "type", "=", "aarch_branch_protect_types", ";", "bool", "found", "=", "false", ";", "while", "(", "type", "&&", "type", "->", "name", "&&", "!", "found", "&&", "res", "==", "AARCH_PARSE_OK", ")", "{", "if", "(", "strcmp", "(", "str", ",", "type", "->", "name", ")", "==", "0", ")", "{", "found", "=", "true", ";", "res", "=", "type", "->", "handler", "(", "str", ",", "next_str", ")", ";", "str", "=", "next_str", ";", "next_str", "=", "strtok_r", "(", "NULL", ",", "\"+\"", ",", "&", "token_save", ")", ";", "}", "else", "type", "++", ";", "}", "if", "(", "found", "&&", "res", "==", "AARCH_PARSE_OK", ")", "{", "bool", "found_subtype", "=", "true", ";", "while", "(", "found_subtype", ")", "{", "found_subtype", "=", "false", ";", "const", "aarch_branch_protect_type", "*", "subtype", "=", "type", "->", "subtypes", ";", "while", "(", "str", "&&", "subtype", "&&", "subtype", "->", "name", "&&", "!", "found_subtype", "&&", "res", "==", "AARCH_PARSE_OK", ")", "{", "if", "(", "strcmp", "(", "str", ",", "subtype", "->", "name", ")", "==", "0", ")", "{", "found_subtype", "=", "true", ";", "res", "=", "subtype", "->", "handler", "(", "str", ",", "next_str", ")", ";", "str", "=", "next_str", ";", "next_str", "=", "strtok_r", "(", "NULL", ",", "\"+\"", ",", "&", "token_save", ")", ";", "}", "else", "subtype", "++", ";", "}", "}", "}", "else", "if", "(", "!", "found", ")", "res", "=", "AARCH_PARSE_INVALID_ARG", ";", "}", "}", "if", "(", "last_str", ")", "{", "if", "(", "str", ")", "strcpy", "(", "*", "last_str", ",", "str", ")", ";", "else", "*", "last_str", "=", "NULL", ";", "}", "if", "(", "res", "==", "AARCH_PARSE_OK", ")", "{", "if", "(", "!", "accepted_branch_protection_string", ")", "accepted_branch_protection_string", "=", "(", "char", "*", ")", "xmalloc", "(", "BRANCH_PROTECT_STR_MAX", "+", "1", ")", ";", "strncpy", "(", "accepted_branch_protection_string", ",", "const_str", ",", "BRANCH_PROTECT_STR_MAX", "+", "1", ")", ";", "accepted_branch_protection_string", "[", "BRANCH_PROTECT_STR_MAX", "]", "=", "'\\0'", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Parses", "CONST_STR", "for", "branch", "protection", "features", "specified", "in", "aarch64_branch_protect_types", ",", "and", "set", "any", "global", "variables", "required", ".", "Returns", "the", "parsing", "result", "and", "assigns", "LAST_STR", "to", "the", "last", "processed", "token", "from", "CONST_STR", "so", "that", "it", "can", "be", "used", "for", "error", "reporting", "." ]

[ "arm", "\"+\"", "\"+\"", "0", "\"+\"", "0", "\"+\"", "1", "1" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ",", "bool", "is64Bit", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "HasXOP", "(", "false", ")", ",", "HasMOVBE", "(", "false", ")", ",", "HasRDRAND", "(", "false", ")", ",", "HasF16C", "(", "false", ")", ",", "HasFSGSBase", "(", "false", ")", ",", "HasLZCNT", "(", "false", ")", ",", "HasBMI", "(", "false", ")", ",", "HasBMI2", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "HasCmpxchg16b", "(", "false", ")", ",", "UseLeaForSP", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "In64BitMode", "(", "is64Bit", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", "||", "!", "CPU", ".", "empty", "(", ")", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "||", "defined", "(", "__x86_64__", ")", "||", "defined", "(", "_M_AMD64", ")", "||", "defined", "(", "_M_X64", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "In64BitMode", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+64bit,+sse2,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+64bit,+sse2\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "}", "else", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "In64BitMode", ")", "{", "HasX86_64", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "Feature64Bit", ")", ";", "HasCMov", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "FeatureCMOV", ")", ";", "if", "(", "X86SSELevel", "<", "SSE2", ")", "{", "X86SSELevel", "=", "SSE2", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE1", ")", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE2", ")", ";", "}", "}", "}", "if", "(", "X86ProcFamily", "==", "IntelAtom", ")", "{", "PostRAScheduler", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "}", "if", "(", "In64BitMode", ")", "ToggleFeature", "(", "X86", "::", "Mode64Bit", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "In64BitMode", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "StackAlignOverride", ";", "else", "if", "(", "isTargetDarwin", "(", ")", "||", "isTargetFreeBSD", "(", ")", "||", "isTargetLinux", "(", ")", "||", "isTargetSolaris", "(", ")", "||", "In64BitMode", ")", "stackAlignment", "=", "16", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "4", "128", "\"generic\"", "\"+64bit,+sse2,\"", "\"+64bit,+sse2\"", "\"generic\"", "X86", "X86::Feature64Bit", "X86::FeatureCMOV", "X86", "X86", "X86::FeatureSSE1", "X86::FeatureSSE2", "X86", "X86::Mode64Bit", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_alloc_pool", "(", "void", ")", "{", "struct", "constant_pool", "*", "pool", ";", "size_t", "i", ";", "pool", "=", "(", "struct", "constant_pool", "*", ")", "xmalloc", "(", "sizeof", "*", "pool", ")", ";", "pool", "->", "next", "=", "NULL", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "pool", "->", "constants", "[", "i", "]", "=", "NULL", ";", "pool", "->", "execute", "=", "NULL", ";", "pool", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "pool", "->", "first_insn", "=", "NULL", ";", "pool", "->", "pool_insn", "=", "NULL", ";", "pool", "->", "insns", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "pool", "->", "size", "=", "0", ";", "pool", "->", "emit_pool_after", "=", "NULL", ";", "return", "pool", ";", "}", "</s>" ]

[ "Allocate", "new", "constant_pool", "structure", "." ]

[ "s390", "0", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "if", "(", "isALU", "(", "*", "I", ")", ")", "{", "auto", "next", "=", "MakeALUClause", "(", "MBB", ",", "I", ")", ";", "assert", "(", "next", "!=", "I", ")", ";", "I", "=", "next", ";", "}", "else", "++", "I", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600::CF_ALU" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isEndLoopN", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCannot predicate:\"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "0", ",", "NumOps", "=", "MI", "->", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "addOperand", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", "->", "getNumOperands", "(", ")", ")", "MI", "->", "RemoveOperand", "(", "n", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", "->", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "&", "*", "T", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "\"\\nCannot predicate:\"", "\"Expected predicable instruction\"", "0", "1", "0" ]

[]

[ "<s>", "bool", "AMDGPUPeepholeOpt", "::", "runOnFunction", "(", "Function", "&", "MF", ")", "{", "mChanged", "=", "false", ";", "mF", "=", "&", "MF", ";", "mSTM", "=", "&", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "mDebug", ")", "{", "MF", ".", "dump", "(", ")", ";", "}", "mCTX", "=", "&", "MF", ".", "getType", "(", ")", "->", "getContext", "(", ")", ";", "mConvertAtomics", "=", "true", ";", "safeNestedForEach", "(", "MF", ".", "begin", "(", ")", ",", "MF", ".", "end", "(", ")", ",", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "std", "::", "bind1st", "(", "std", "::", "mem_fun", "(", "&", "AMDGPUPeepholeOpt", "::", "instLevelOptimizations", ")", ",", "this", ")", ")", ";", "doAtomicConversionIfNeeded", "(", "MF", ")", ";", "doIsConstCallConversionIfNeeded", "(", ")", ";", "if", "(", "mDebug", ")", "{", "MF", ".", "dump", "(", ")", ";", "}", "return", "mChanged", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "R600" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "const", "char", "*", "mcore_output_movedouble", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "REG", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "dstreg", "=", "REGNO", "(", "dst", ")", ";", "int", "srcreg", "=", "REGNO", "(", "src", ")", ";", "if", "(", "srcreg", "+", "1", "==", "dstreg", ")", "return", "\"mov\t%R0,%R1\\n\\tmov\t%0,%1\"", ";", "else", "return", "\"mov\t%0,%1\\n\\tmov\t%R0,%R1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "rtx", "memexp", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "dstreg", "=", "REGNO", "(", "dst", ")", ";", "int", "basereg", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "LABEL_REF", ")", "return", "\"lrw\\t%0,[%1]\\n\\tlrw\\t%R0,[%R1]\"", ";", "else", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "memexp", ")", ";", "else", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "0", ")", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "XEXP", "(", "memexp", ",", "0", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "1", ")", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "XEXP", "(", "memexp", ",", "1", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "dstreg", "==", "basereg", ")", "{", "return", "\"ldw\\t%R0,%R1\\n\\tldw\\t%0,%1\"", ";", "}", "else", "return", "\"ldw\\t%0,%1\\n\\tldw\\t%R0,%R1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "if", "(", "TARGET_LITTLE_END", ")", "{", "if", "(", "CONST_OK_FOR_I", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"movi\t%0,%1\"", ",", "operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"bgeni\t%0,%P1\"", ",", "operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"bmaski\t%0,%N1\"", ",", "operands", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "INTVAL", "(", "src", ")", "<", "0", ")", "return", "\"bmaski\t%R0,32\"", ";", "else", "return", "\"movi\t%R0,0\"", ";", "}", "else", "{", "if", "(", "CONST_OK_FOR_I", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"movi\t%R0,%1\"", ",", "operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"bgeni\t%R0,%P1\"", ",", "operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", ")", ")", "output_asm_insn", "(", "\"bmaski\t%R0,%N1\"", ",", "operands", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "INTVAL", "(", "src", ")", "<", "0", ")", "return", "\"bmaski\t%0,32\"", ";", "else", "return", "\"movi\t%0,0\"", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "GET_CODE", "(", "src", ")", "==", "REG", ")", "return", "\"stw\\t%1,%0\\n\\tstw\\t%R1,%R0\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "sequence", "of", "instructions", "to", "perform", "DI", "or", "DF", "move", ".", "Since", "the", "MCORE", "can", "not", "move", "a", "DI", "or", "DF", "in", "one", "instruction", ",", "we", "have", "to", "take", "care", "when", "we", "see", "overlapping", "source", "and", "dest", "registers", "." ]

[ "mcore", "0", "1", "1", "\"mov\t%R0,%R1\\n\\tmov\t%0,%1\"", "\"mov\t%0,%1\\n\\tmov\t%R0,%R1\"", "0", "1", "\"lrw\\t%0,[%1]\\n\\tlrw\\t%R0,[%R1]\"", "0", "0", "1", "1", "\"ldw\\t%R0,%R1\\n\\tldw\\t%0,%1\"", "\"ldw\\t%0,%1\\n\\tldw\\t%R0,%R1\"", "\"movi\t%0,%1\"", "\"bgeni\t%0,%P1\"", "\"bmaski\t%0,%N1\"", "0", "\"bmaski\t%R0,32\"", "\"movi\t%R0,0\"", "\"movi\t%R0,%1\"", "\"bgeni\t%R0,%P1\"", "\"bmaski\t%R0,%N1\"", "0", "\"bmaski\t%0,32\"", "\"movi\t%0,0\"", "\"stw\\t%1,%0\\n\\tstw\\t%R1,%R0\"" ]

[]

[ "<s>", "static", "void", "ix86_test_loading_call_insn", "(", ")", "{", "if", "(", "!", "TARGET_SSE", ")", "return", ";", "rtl_dump_test", "t", "(", "SELFTEST_LOCATION", ",", "locate_file", "(", "\"x86_64/call-insn.rtl\"", ")", ")", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "ASSERT_EQ", "(", "CALL_INSN", ",", "GET_CODE", "(", "insn", ")", ")", ";", "ASSERT_TRUE", "(", "RTX_FLAG", "(", "insn", ",", "jump", ")", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "ASSERT_EQ", "(", "CALL", ",", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", ")", ";", "{", "ASSERT_EQ", "(", "EXPR_LIST", ",", "GET_CODE", "(", "REG_NOTES", "(", "insn", ")", ")", ")", ";", "rtx_expr_list", "*", "note0", "=", "as_a", "<", "rtx_expr_list", "*", ">", "(", "REG_NOTES", "(", "insn", ")", ")", ";", "ASSERT_EQ", "(", "REG_CALL_DECL", ",", "REG_NOTE_KIND", "(", "note0", ")", ")", ";", "rtx_expr_list", "*", "note1", "=", "note0", "->", "next", "(", ")", ";", "ASSERT_EQ", "(", "REG_EH_REGION", ",", "REG_NOTE_KIND", "(", "note1", ")", ")", ";", "ASSERT_EQ", "(", "NULL", ",", "note1", "->", "next", "(", ")", ")", ";", "}", "{", "rtx_expr_list", "*", "usage", "=", "as_a", "<", "rtx_expr_list", "*", ">", "(", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ")", ";", "ASSERT_EQ", "(", "EXPR_LIST", ",", "GET_CODE", "(", "usage", ")", ")", ";", "ASSERT_EQ", "(", "DFmode", ",", "GET_MODE", "(", "usage", ")", ")", ";", "ASSERT_EQ", "(", "USE", ",", "GET_CODE", "(", "usage", "->", "element", "(", ")", ")", ")", ";", "ASSERT_EQ", "(", "NULL", ",", "usage", "->", "next", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Verify", "that", "the", "RTL", "loader", "copes", "with", "a", "call_insn", "dump", ".", "This", "test", "is", "target-specific", "since", "the", "dump", "contains", "a", "target-specific", "hard", "reg", "name", "." ]

[ "i386", "\"x86_64/call-insn.rtl\"" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAArch64ISelDAG", "(", "getAArch64TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "getAArch64Subtarget", "(", ")", ".", "isTargetELF", "(", ")", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64CleanupLocalDynamicTLSPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "insert", "(", "const", "RegisterAggr", "&", "RG", ")", "{", "Units", "|=", "RG", ".", "Units", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

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

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

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MRI", ".", "getTargetRegisterInfo", "(", ")", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getRegSizeInBits", "(", "*", "RC", ")", ";", "unsigned", "Opcode", "=", "(", "Size", "==", "64", ")", "?", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "(", "Size", "==", "64", ")", "?", "AMDGPU", "::", "S_MOV_B64", ":", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "Register", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "add", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "AMDGPU", "SI", "SI", "SI", "64", "AMDGPU::V_MOV_B64_PSEUDO", "AMDGPU::V_MOV_B32_e32", "AMDGPU::COPY", "64", "AMDGPU::S_MOV_B64", "AMDGPU::S_MOV_B32", "AMDGPU::VReg_64RegClass", "AMDGPU::VReg_64RegClass", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "void", "FISCAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "isPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "4", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "NumBytes", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "FISC", "FISC", "4", "\"Invalid fixup offset!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "rtx", "cr16_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "cr16_ret_register", "(", ")", ")", ";", "}", "</s>" ]

[ "Implements", "hook", "TARGET_STRUCT_VALUE_RTX", "." ]

[ "cr16" ]

[]

[ "<s>", "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "*", "MI", "=", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&&", "\"CF ALU instruction disabled\"", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "8", "\"CF ALU instruction disabled\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Lower control flow instructions\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Lower control flow instructions\"" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "P2" ]

[]

[ "<s>", "int", "tilegx_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "total_size", "=", "compute_total_frame_size", "(", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "total_size", "-", "crtl", "->", "args", ".", "pretend_args_size", "-", "tilegx_saved_regs_size", "(", ")", ")", ";", "}", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "return", "-", "(", "crtl", "->", "args", ".", "pretend_args_size", "+", "tilegx_saved_regs_size", "(", ")", ")", ";", "}", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "STACK_POINTER_OFFSET", "+", "total_size", ";", "}", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "return", "STACK_POINTER_OFFSET", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "shouldSimplifyDemandedVectorElts", "(", "SDValue", "Op", ",", "const", "TargetLoweringOpt", "&", "TLO", ")", "const", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", "&&", "TLO", ".", "LegalOps", "&&", "TLO", ".", "LegalTys", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "simplifying", "demanded", "vector", "elements", "by", "converting", "them", "to", "undefs", "." ]

[ "WebAssembly", "WebAssembly", "ISD::BUILD_VECTOR" ]

[]

[ "<s>", "void", "UPTAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "UPT", "UPT" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_JT", ":", "return", "lowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "lowerADD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "lowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BR_JT", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::ADD", "ISD::FP_TO_SINT" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

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

[]

[ "<s>", "rtx", "mmix_dynamic_chain_address", "(", "rtx", "frame", ")", "{", "return", "plus_constant", "(", "frame", ",", "-", "8", ")", ";", "}", "</s>" ]

[ "DYNAMIC_CHAIN_ADDRESS", "." ]

[ "mmix", "8" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ".", "StackAlignmentOverride", ",", "is64Bit", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_set_handled_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "gpr_is_wrapped_separately", "[", "i", "]", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "cfun", "->", "machine", "->", "lr_is_wrapped_separately", "=", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS", "." ]

[ "rs6000", "32", "0" ]

[]

[ "<s>", "static", "void", "arm_option_override_internal", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "arm_override_options_after_change_1", "(", "opts", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support THUMB instructions\"", ")", ";", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_APCS_FRAME", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "opts", "->", "x_target_flags", "|=", "MASK_INTERWORK", ";", "cl_optimization", "*", "to", "=", "TREE_OPTIMIZATION", "(", "init_optimize", ")", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", ")", "opts", "->", "x_arm_restrict_it", "=", "arm_arch8", ";", "if", "(", "!", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", "||", "!", "arm_arch_notm", ")", "opts", "->", "x_arm_restrict_it", "=", "0", ";", "if", "(", "!", "opts_set", "->", "x_unaligned_access", ")", "{", "opts", "->", "x_unaligned_access", "=", "(", "TARGET_32BIT_P", "(", "opts", "->", "x_target_flags", ")", "&&", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ";", "}", "else", "if", "(", "opts", "->", "x_unaligned_access", "==", "1", "&&", "!", "(", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support unaligned accesses\"", ")", ";", "opts", "->", "x_unaligned_access", "=", "0", ";", "}", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_schedule_insns", "=", "0", ";", "else", "opts", "->", "x_flag_schedule_insns", "=", "to", "->", "x_flag_schedule_insns", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_shrink_wrap", "=", "false", ";", "else", "opts", "->", "x_flag_shrink_wrap", "=", "to", "->", "x_flag_shrink_wrap", ";", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_ipa_ra", "=", "0", ";", "else", "opts", "->", "x_flag_ipa_ra", "=", "to", "->", "x_flag_ipa_ra", ";", "opts", "->", "x_inline_asm_unified", "=", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ";", "SUBTARGET_OVERRIDE_INTERNAL_OPTIONS", ";", "}", "</s>" ]

[ "Reset", "options", "between", "modes", "that", "the", "user", "has", "specified", "." ]

[ "arm", "0", "\"target CPU does not support THUMB instructions\"", "0", "1", "0", "\"target CPU does not support unaligned accesses\"", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "ft32_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "named_size", "=", "GET_MODE_SIZE", "(", "SImode", ")", "*", "(", "*", "cum", "-", "FT32_R0", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "named_size", "<", "24", ")", "*", "pretend_size", "=", "24", "-", "named_size", ";", "else", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

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

[ "ft32", "24", "24", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalStoreImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "32", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "for", "the", "value", "input", "of", "a", "store", "instruction", "." ]

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

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'H'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "O", ",", "\"H\"", ")", ";", "return", "false", ";", "case", "'P'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "O", ",", "\"no-rip\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "X86", "X86", "0", "1", "0", "0", "\"H\"", "\"no-rip\"" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "HasFP32Denormals", "=", "ST", "->", "hasFP32Denormals", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "Function", "::", "iterator", "NextBB", ";", "for", "(", "Function", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "FI", "=", "NextBB", ")", "{", "BasicBlock", "*", "BB", "=", "&", "*", "FI", ";", "NextBB", "=", "std", "::", "next", "(", "FI", ")", ";", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ",", "E", "=", "BB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "if", "(", "Next", "!=", "E", ")", "{", "BasicBlock", "*", "NextInstBB", "=", "Next", "->", "getParent", "(", ")", ";", "if", "(", "NextInstBB", "!=", "BB", ")", "{", "BB", "=", "NextInstBB", ";", "E", "=", "BB", "->", "end", "(", ")", ";", "FE", "=", "F", ".", "end", "(", ")", ";", "}", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "bool", "rs6000_is_valid_and_mask", "(", "rtx", "mask", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "DImode", ")", "return", "(", "ne", "==", "0", "||", "nb", "==", "63", "||", "(", "nb", "<", "32", "&&", "ne", "<=", "nb", ")", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlwinm", ",", "rldicl", ",", "or", "rldicr", "instruction", ",", "to", "implement", "an", "AND", "with", "it", "in", "mode", "MODE", "." ]

[ "rs6000", "0", "63", "32", "32", "32" ]

[]

[ "<s>", "char", "*", "aarch64_output_ptrue", "(", "machine_mode", "mode", ",", "char", "suffix", ")", "{", "unsigned", "int", "nunits", ";", "static", "char", "buf", "[", "sizeof", "(", "\"ptrue\\t%0.N, vlNNNNN\"", ")", "]", ";", "if", "(", "GET_MODE_NUNITS", "(", "mode", ")", ".", "is_constant", "(", "&", "nunits", ")", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"ptrue\\t%%0.%c, vl%d\"", ",", "suffix", ",", "nunits", ")", ";", "else", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"ptrue\\t%%0.%c, all\"", ",", "suffix", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Return", "the", "asm", "format", "for", "a", "PTRUE", "instruction", "whose", "destination", "has", "mode", "MODE", ".", "SUFFIX", "is", "the", "element", "size", "suffix", "." ]

[ "aarch64", "\"ptrue\\t%0.N, vlNNNNN\"", "\"ptrue\\t%%0.%c, vl%d\"", "\"ptrue\\t%%0.%c, all\"" ]

[]

[ "<s>", "bool", "PatmosSPClone", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "SPRoots", ".", "empty", "(", ")", ")", "{", "errs", "(", ")", "<<", "\"Following single-path roots were not found:\\n\"", ";", "for", "(", "std", "::", "set", "<", "std", "::", "string", ">", "::", "iterator", "it", "=", "SPRoots", ".", "begin", "(", ")", ";", "it", "!=", "SPRoots", ".", "end", "(", ")", ";", "++", "it", ")", "{", "errs", "(", ")", "<<", "\"'\"", "<<", "*", "it", "<<", "\"' \"", ";", "}", "errs", "(", ")", "<<", "'\\n'", ";", "SPRoots", ".", "clear", "(", ")", ";", "report_fatal_error", "(", "\"Single-path code generation failed due to \"", "\"missing single-path entry functions!\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "Patmos", "Patmos", "\"Following single-path roots were not found:\\n\"", "\"'\"", "\"' \"", "\"Single-path code generation failed due to \"", "\"missing single-path entry functions!\"" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "const", "ARMGOT", "&", "ARMGNULDBackend", "::", "getGOT", "(", ")", "const", "{", "assert", "(", "m_pGOT", "!=", "NULL", "&&", "\"GOT section not exist\"", ")", ";", "return", "*", "m_pGOT", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ "ARM", "ARM", "ARM", "\"GOT section not exist\"" ]

[]

[ "<s>", "SIScheduleBlocks", "SIScheduleBlockCreator", "::", "getBlocks", "(", "SISchedulerBlockCreatorVariant", "BlockVariant", ")", "{", "std", "::", "map", "<", "SISchedulerBlockCreatorVariant", ",", "SIScheduleBlocks", ">", "::", "iterator", "B", "=", "Blocks", ".", "find", "(", "BlockVariant", ")", ";", "if", "(", "B", "==", "Blocks", ".", "end", "(", ")", ")", "{", "SIScheduleBlocks", "Res", ";", "createBlocksForVariant", "(", "BlockVariant", ")", ";", "topologicalSort", "(", ")", ";", "scheduleInsideBlocks", "(", ")", ";", "fillStats", "(", ")", ";", "Res", ".", "Blocks", "=", "CurrentBlocks", ";", "Res", ".", "TopDownIndex2Block", "=", "TopDownIndex2Block", ";", "Res", ".", "TopDownBlock2Index", "=", "TopDownBlock2Index", ";", "Blocks", "[", "BlockVariant", "]", "=", "Res", ";", "return", "Res", ";", "}", "else", "{", "return", "B", "->", "second", ";", "}", "}", "</s>" ]

[ "Get", "a", "list", "of", "the", "basic", "blocks", "which", "make", "up", "this", "loop", "." ]

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "\"Empty shufflevector input\"", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "\"Unmatched number of shufflevectors and indices\"", ")", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "0", "]", "->", "getType", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", ";", "if", "(", "VecSize", "!=", "64", "&&", "VecSize", "!=", "128", ")", "return", "false", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "Type", "*", "PtrTy", "=", "VecTy", "->", "getPointerTo", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Type", "*", "Tys", "[", "2", "]", "=", "{", "VecTy", ",", "PtrTy", "}", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "aarch64_neon_ld2", ",", "Intrinsic", "::", "aarch64_neon_ld3", ",", "Intrinsic", "::", "aarch64_neon_ld4", "}", ";", "Function", "*", "LdNFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "Value", "*", "Ptr", "=", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "PtrTy", ")", ";", "CallInst", "*", "LdN", "=", "Builder", ".", "CreateCall", "(", "LdNFunc", ",", "Ptr", ",", "\"ldN\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SVI", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "LdN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SVI", "->", "getType", "(", ")", ")", ";", "SVI", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "AArch64", "AArch64", "2", "\"Invalid interleave factor\"", "\"Empty shufflevector input\"", "\"Unmatched number of shufflevectors and indices\"", "0", "64", "128", "2", "Intrinsic::ID", "3", "Intrinsic::aarch64_neon_ld2", "Intrinsic::aarch64_neon_ld3", "Intrinsic::aarch64_neon_ld4", "Intrinsic::getDeclaration", "2", "\"ldN\"", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUCallLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "llvm_unreachable", "(", "\"kernels should not be handled here\"", ")", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_LS", ":", "return", "RetCC_SI_Shader", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "RetCC_AMDGPU_Func", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"kernels should not be handled here\"", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "SI", "AMDGPU", "\"Unsupported calling convention.\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Pre-RA optimizations\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Pre-RA optimizations\"" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "Root", ")", "{", "delete", "Root", ";", "Root", "=", "NULL", ";", "}", "auto", "curfunc", "=", "MF", ".", "getFunction", "(", ")", ".", "getName", "(", ")", ";", "if", "(", "isConverting", "(", "MF", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Analyze '\"", "<<", "curfunc", "<<", "\"'\\n\"", ")", ";", "analyzeFunction", "(", "MF", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"[Single-Path] Analyze '\"", "\"'\\n\"" ]

[]

[ "<s>", "bool", "can_be_rotated_to_lowbits", "(", "unsigned", "HOST_WIDE_INT", "c", ",", "int", "lowbits", ",", "int", "*", "rot", ")", "{", "int", "clz", "=", "HOST_BITS_PER_WIDE_INT", "-", "lowbits", ";", "int", "lz", "=", "clz_hwi", "(", "c", ")", ";", "if", "(", "lz", ">=", "clz", ")", "{", "*", "rot", "=", "0", ";", "return", "true", ";", "}", "int", "tz", "=", "ctz_hwi", "(", "c", ")", ";", "if", "(", "lz", "+", "tz", ">=", "clz", ")", "{", "*", "rot", "=", "HOST_BITS_PER_WIDE_INT", "-", "tz", ";", "return", "true", ";", "}", "const", "int", "rot_bits", "=", "lowbits", "+", "1", ";", "unsigned", "HOST_WIDE_INT", "rc", "=", "(", "c", ">>", "rot_bits", ")", "|", "(", "c", "<<", "(", "clz", "-", "1", ")", ")", ";", "tz", "=", "ctz_hwi", "(", "rc", ")", ";", "if", "(", "clz_hwi", "(", "rc", ")", "+", "tz", ">=", "clz", ")", "{", "*", "rot", "=", "HOST_BITS_PER_WIDE_INT", "-", "(", "tz", "+", "rot_bits", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "C", "(", "as", "64bit", "integer", ")", "can", "be", "rotated", "to", "a", "constant", "which", "constains", "nonzero", "bits", "at", "the", "LOWBITS", "low", "bits", "only", ".", "Return", "true", "if", "C", "can", "be", "rotated", "to", "such", "constant", ".", "If", "so", ",", "*", "ROT", "is", "written", "to", "the", "number", "by", "which", "C", "is", "rotated", ".", "Return", "false", "otherwise", "." ]

[ "rs6000", "0", "1", "1" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "new", "ARMExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "restrictIT", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createIfConverter", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "}", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "const", "char", "*", "KudeyarAsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "{", "}", "return", "\"abi32\"", ";", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Kudeyar", "Kudeyar", "\"abi32\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 FP Stackifier\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 FP Stackifier\"" ]

[]

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

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::STXri", "0", "SP::IntRegsRegClass", "SP::STri", "0", "SP::FPRegsRegClass", "SP::STFri", "0", "SP::DFPRegsRegClass", "SP::STDFri", "0", "\"Can't store this register to stack slot\"" ]

[]

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

[ ".functype" ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "bool", "s390_fix_long_loop_prediction", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "code_label", ",", "label_ref", ",", "new_label", ";", "rtx_insn", "*", "uncond_jump", ";", "rtx_insn", "*", "cur_insn", ";", "rtx", "tmp", ";", "int", "distance", ";", "if", "(", "!", "set", "||", "SET_DEST", "(", "set", ")", "!=", "pc_rtx", "||", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "!=", "IF_THEN_ELSE", ")", "return", "false", ";", "if", "(", "ANY_RETURN_P", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "&&", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "==", "pc_rtx", ")", "return", "false", ";", "label_ref", "=", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "==", "LABEL_REF", "?", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ":", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "label_ref", ")", "==", "LABEL_REF", ")", ";", "code_label", "=", "XEXP", "(", "label_ref", ",", "0", ")", ";", "if", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "==", "-", "1", "||", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "==", "-", "1", "||", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "<", "PREDICT_DISTANCE", ")", ")", "return", "false", ";", "for", "(", "distance", "=", "0", ",", "cur_insn", "=", "PREV_INSN", "(", "insn", ")", ";", "distance", "<", "PREDICT_DISTANCE", "-", "6", ";", "distance", "+=", "get_attr_length", "(", "cur_insn", ")", ",", "cur_insn", "=", "PREV_INSN", "(", "cur_insn", ")", ")", "if", "(", "!", "cur_insn", "||", "JUMP_P", "(", "cur_insn", ")", "||", "LABEL_P", "(", "cur_insn", ")", ")", "return", "false", ";", "new_label", "=", "gen_label_rtx", "(", ")", ";", "uncond_jump", "=", "emit_jump_insn_after", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "code_label", ")", ")", ",", "insn", ")", ";", "emit_label_after", "(", "new_label", ",", "uncond_jump", ")", ";", "tmp", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "=", "tmp", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "XEXP", "(", "label_ref", ",", "0", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "insn", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "uncond_jump", ")", "=", "code_label", ";", "return", "true", ";", "}", "</s>" ]

[ "On", "z10", "and", "later", "the", "dynamic", "branch", "prediction", "must", "see", "the", "backward", "jump", "within", "a", "certain", "windows", ".", "If", "not", "it", "falls", "back", "to", "the", "static", "prediction", ".", "This", "function", "rearranges", "the", "loop", "backward", "branch", "in", "a", "way", "which", "makes", "the", "static", "prediction", "always", "correct", ".", "The", "function", "returns", "true", "if", "it", "added", "an", "instruction", "." ]

[ "s390", "1", "2", "1", "1", "2", "0", "1", "1", "0", "6", "1", "1", "2", "2", "1", "0" ]

[]

[ "<s>", "static", "int", "m32r_is_insn", "(", "rtx", "insn", ")", "{", "return", "(", "NONDEBUG_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "real", "instruction", "bearing", "insn", "." ]

[ "m32r" ]

[]

[ "<s>", "unsigned", "XCoreInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "IsBRU", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "!", "IsCondBranch", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "IsCondBranch", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "XCore", "XCore", "\"code size not handled\"", "0", "0", "1", "1", "2" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"NVPTX Replace Image Handles\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"NVPTX Replace Image Handles\"" ]

[]

[ "<s>", "Register", "RISCVTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "MatchRegisterAltName", "(", "RegName", ")", ";", "if", "(", "Reg", "==", "RISCV", "::", "NoRegister", ")", "Reg", "=", "MatchRegisterName", "(", "RegName", ")", ";", "if", "(", "Reg", "==", "RISCV", "::", "NoRegister", ")", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "BitVector", "ReservedRegs", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "getReservedRegs", "(", "MF", ")", ";", "if", "(", "!", "ReservedRegs", ".", "test", "(", "Reg", ")", "&&", "!", "Subtarget", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "report_fatal_error", "(", "Twine", "(", "\"Trying to obtain non-reserved register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "RISCV", "RISCV", "RISCV::NoRegister", "RISCV::NoRegister", "\"Invalid register name \\\"\"", "\"\\\".\"", "\"Trying to obtain non-reserved register \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMTargetLowering", "::", "getRegClassFor", "(", "MVT", "VT", ")", "const", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "v4i64", ")", "return", "&", "ARM", "::", "QQPRRegClass", ";", "if", "(", "VT", "==", "MVT", "::", "v8i64", ")", "return", "&", "ARM", "::", "QQQQPRRegClass", ";", "}", "return", "TargetLowering", "::", "getRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "that", "should", "be", "used", "for", "the", "specified", "value", "type", "." ]

[ "ARM", "ARM", "MVT::v4i64", "ARM::QQPRRegClass", "MVT::v8i64", "ARM::QQQQPRRegClass" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "ArgsPreserved", "=", "64", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "ArgsPreserved", ",", "8", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_VE", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"TODO implement argument passing on stack\"", ")", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "unsigned", "VReg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "getRegClassFor", "(", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "VA", ".", "getLocVT", "(", ")", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VA", ".", "needsCustom", "(", ")", ")", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ",", "DAG", ".", "getConstant", "(", "32", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "VA", ".", "isExtInLoc", "(", ")", ")", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Arg", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "continue", ";", "}", "}", "assert", "(", "!", "IsVarArg", "&&", "\"TODO implement var args\"", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "VE", "VE", "ISD::InputArg", "64", "16", "8", "VE", "0", "\"TODO implement argument passing on stack\"", "MVT::i32", "ISD::SRL", "32", "MVT::i32", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"TODO implement var args\"" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolution", ">", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "DataLayoutPass", "*", "DLP", "=", "getAnalysisIfAvailable", "<", "DataLayoutPass", ">", "(", ")", ";", "DL", "=", "DLP", "?", "&", "DLP", "->", "getDataLayout", "(", ")", ":", "nullptr", ";", "auto", "*", "TLIP", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "LibInfo", "=", "TLIP", "?", "&", "TLIP", "->", "getTLI", "(", ")", ":", "nullptr", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "MadeChange", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "restrictIT", "(", ")", "&&", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::DPRRegClass", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "mark_reg_gr_used_mask", "(", "rtx", "reg", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "regno", "<", "32", ")", "{", "unsigned", "int", "i", ",", "n", "=", "hard_regno_nregs", "[", "regno", "]", "[", "GET_MODE", "(", "reg", ")", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "++", "i", ")", "current_frame_info", ".", "gr_used_mask", "|=", "1", "<<", "(", "regno", "+", "i", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "ia64_compute_frame_size", ",", "called", "through", "diddle_return_value", ".", "Mark", "REG", "in", "current_frame_info.gr_used_mask", "." ]

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

[]

[ "<s>", "static", "rtx", "arc_expand_builtin_aligned", "(", "tree", "exp", ")", "{", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "fold", "(", "arg1", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "{", "if", "(", "optimize", ")", "warning", "(", "0", ",", "\"__builtin_arc_aligned with non-constant alignment\"", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "alignTest", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "alignTest", "<=", "0", "||", "alignTest", "!=", "(", "alignTest", "&", "-", "alignTest", ")", ")", "{", "error", "(", "\"invalid alignment value for __builtin_arc_aligned\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "CONST_INT_P", "(", "op0", ")", ")", "{", "HOST_WIDE_INT", "pnt", "=", "INTVAL", "(", "op0", ")", ";", "if", "(", "(", "pnt", "&", "(", "alignTest", "-", "1", ")", ")", "==", "0", ")", "return", "const1_rtx", ";", "}", "else", "{", "unsigned", "align", "=", "get_pointer_alignment", "(", "arg0", ")", ";", "unsigned", "numBits", "=", "alignTest", "*", "BITS_PER_UNIT", ";", "if", "(", "align", "&&", "align", ">=", "numBits", ")", "return", "const1_rtx", ";", "if", "(", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "arg0", ")", ")", "&&", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ">=", "numBits", ")", "return", "const1_rtx", ";", "}", "}", "return", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "to", "expand", "__builtin_arc_aligned", "(", "void", "*", "val", ",", "int", "alignval", ")", "." ]

[ "arc", "0", "1", "0", "\"__builtin_arc_aligned with non-constant alignment\"", "0", "\"invalid alignment value for __builtin_arc_aligned\"", "1", "0" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "64", ")", ";", "LLT", "s64", "=", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "IsTailCall", ")", "{", "Offset", "+=", "FPDiff", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "auto", "FIReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "p0", ",", "FI", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "return", "FIReg", ".", "getReg", "(", "0", ")", ";", "}", "if", "(", "!", "SPReg", ")", "SPReg", "=", "MIRBuilder", ".", "buildCopy", "(", "p0", ",", "Register", "(", "AArch64", "::", "SP", ")", ")", ".", "getReg", "(", "0", ")", ";", "auto", "OffsetReg", "=", "MIRBuilder", ".", "buildConstant", "(", "s64", ",", "Offset", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "p0", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "AArch64", "0", "64", "64", "0", "AArch64::SP", "0", "0" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "bool", "VETargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int64_t", "getStackPointerBias", "(", ")", "const", "{", "return", "is64Bit", "(", ")", "?", "2047", ":", "0", ";", "}", "</s>" ]

[ "The", "64-bit", "ABI", "uses", "biased", "stack", "and", "frame", "pointers", ",", "so", "the", "stack", "frame", "of", "the", "current", "function", "is", "the", "area", "from", "[", "sp+BIAS", "]", "to", "[", "fp+BIAS", "]", "." ]

[ "WDC65816", "2047", "0" ]

[]

[ "<s>", "bool", "PPCFunctionInfo", "::", "isLiveInSExt", "(", "Register", "VReg", ")", "const", "{", "for", "(", "const", "std", "::", "pair", "<", "Register", ",", "ISD", "::", "ArgFlagsTy", ">", "&", "LiveIn", ":", "LiveInAttrs", ")", "if", "(", "LiveIn", ".", "first", "==", "VReg", ")", "return", "LiveIn", ".", "second", ".", "isSExt", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "the", "specified", "vreg", "is", "a", "live-in", "register", "and", "sign-extended", "." ]

[ "PowerPC", "PPC", "ISD::ArgFlagsTy" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "RoundUpToAlignment", "(", "maxCallFrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "RoundUpToAlignment", "(", "FrameSize", ",", "TargetAlign", ")", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "DeadCodeElimination", "::", "collect", "(", ")", "{", "LiveNodes", ".", "clear", "(", ")", ";", "SetVector", "<", "NodeId", ">", "WorkQ", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "DFG", ".", "getFunc", "(", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "scanInstr", "(", "IA", ",", "WorkQ", ")", ";", "while", "(", "!", "WorkQ", ".", "empty", "(", ")", ")", "{", "NodeId", "N", "=", "*", "WorkQ", ".", "begin", "(", ")", ";", "WorkQ", ".", "remove", "(", "N", ")", ";", "LiveNodes", ".", "insert", "(", "N", ")", ";", "auto", "RA", "=", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "N", ")", ";", "if", "(", "DFG", ".", "IsDef", "(", "RA", ")", ")", "processDef", "(", "RA", ",", "WorkQ", ")", ";", "else", "processUse", "(", "RA", ",", "WorkQ", ")", ";", "}", "if", "(", "trace", "(", ")", ")", "{", "dbgs", "(", ")", "<<", "\"Live nodes:\\n\"", ";", "for", "(", "NodeId", "N", ":", "LiveNodes", ")", "{", "auto", "RA", "=", "DFG", ".", "addr", "<", "RefNode", "*", ">", "(", "N", ")", ";", "dbgs", "(", ")", "<<", "PrintNode", "<", "RefNode", "*", ">", "(", "RA", ",", "DFG", ")", "<<", "\"\\n\"", ";", "}", "}", "auto", "IsDead", "=", "[", "this", "]", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ")", "->", "bool", "{", "for", "(", "NodeAddr", "<", "DefNode", "*", ">", "DA", ":", "IA", ".", "Addr", "->", "members_if", "(", "DFG", ".", "IsDef", ",", "DFG", ")", ")", "if", "(", "LiveNodes", ".", "count", "(", "DA", ".", "Id", ")", ")", "return", "false", ";", "return", "true", ";", "}", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "DFG", ".", "getFunc", "(", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "IA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "if", "(", "!", "LiveNodes", ".", "count", "(", "RA", ".", "Id", ")", ")", "DeadNodes", ".", "insert", "(", "RA", ".", "Id", ")", ";", "if", "(", "DFG", ".", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", "(", "IA", ")", ")", "if", "(", "isLiveInstr", "(", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ")", ")", "continue", ";", "if", "(", "IsDead", "(", "IA", ")", ")", "{", "DeadInstrs", ".", "insert", "(", "IA", ".", "Id", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Dead instr: \"", "<<", "PrintNode", "<", "InstrNode", "*", ">", "(", "IA", ",", "DFG", ")", "<<", "\"\\n\"", ";", "}", "}", "}", "return", "!", "DeadNodes", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "instruction", "MI", "and", "fill", "in", "the", "Uses", ",", "Defs", "and", "DeadDefs", "list", "based", "on", "the", "MachineOperand", "flags", "." ]

[ "Hexagon", "\"Live nodes:\\n\"", "\"\\n\"", "\"Dead instr: \"", "\"\\n\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Hazard Schedule\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Hazard Schedule\"" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MFI", ")", ";", "assert", "(", "allSGPRSpillsAreDead", "(", "MF", ")", "&&", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", ")", ";", "if", "(", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FuncInfo", "->", "getScavengeFI", "(", "MFI", ",", "*", "TRI", ")", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", "\"RegScavenger required if spilling\"" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "0", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "NVPTXSubtarget", "&", "NVPTXSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", "&&", "FS", ".", "size", "(", ")", ")", "llvm_unreachable", "(", "\"we are not using FeatureStr\"", ")", ";", "TargetName", "=", "CPU", ".", "empty", "(", ")", "?", "\"sm_20\"", ":", "CPU", ";", "ParseSubtargetFeatures", "(", "TargetName", ",", "FS", ")", ";", "if", "(", "PTXVersion", "==", "0", ")", "{", "PTXVersion", "=", "32", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "\"we are not using FeatureStr\"", "\"sm_20\"", "0", "32" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "isVALU", "(", "*", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "DefinedRC", "->", "getSize", "(", ")", ")", ")", "{", "unsigned", "SGPRUsed", "=", "MO", "->", "isReg", "(", ")", "?", "MO", "->", "getReg", "(", ")", ":", "(", "unsigned", ")", "AMDGPU", "::", "NoRegister", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "!=", "SGPRUsed", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "getOpSize", "(", "*", "MI", ",", "i", ")", ")", ")", "{", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", "->", "getReg", "(", ")", ")", "?", "MRI", ".", "getRegClass", "(", "MO", "->", "getReg", "(", ")", ")", ":", "RI", ".", "getPhysRegClass", "(", "MO", "->", "getReg", "(", ")", ")", ";", "return", "RI", ".", "getCommonSubClass", "(", "RC", ",", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ")", "==", "RC", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::NoRegister", "0" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "AAP" ]

[]

[ "<s>", "bool", "aarch64_sve_prefetch_operand_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "struct", "aarch64_address_info", "addr", ";", "if", "(", "!", "aarch64_classify_address", "(", "&", "addr", ",", "op", ",", "mode", ",", "false", ",", "ADDR_QUERY_ANY", ")", ")", "return", "false", ";", "if", "(", "addr", ".", "type", "==", "ADDRESS_REG_IMM", ")", "return", "offset_6bit_signed_scaled_p", "(", "mode", ",", "addr", ".", "const_offset", ")", ";", "return", "addr", ".", "type", "==", "ADDRESS_REG_REG", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "address", "for", "an", "SVE", "PRF", "[", "BHWD", "]", "instruction", ",", "addressing", "memory", "of", "mode", "MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "rtx", "dest", "=", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "?", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ":", "SET_SRC", "(", "pat", ")", ")", ";", "int", "dest_uid", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "XEXP", "(", "dest", ",", "1", ")", "==", "pc_rtx", "?", "2", ":", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>" ]

[ "Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "." ]

[ "arc", "0", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "static", "bool", "mips_cfun_has_flexible_gp_ref_p", "(", "void", ")", "{", "if", "(", "TARGET_ABICALLS_PIC2", "&&", "!", "reload_completed", "&&", "crtl", "->", "uses_const_pool", ")", "return", "true", ";", "return", "mips_find_gp_ref", "(", "&", "cfun", "->", "machine", "->", "has_flexible_gp_insn_p", ",", "mips_insn_has_flexible_gp_ref_p", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "references", "the", "global", "pointer", ",", "but", "if", "those", "references", "do", "not", "inherently", "require", "the", "global", "pointer", "to", "be", "$", "28", ".", "Assume", "!", "mips_cfun_has_inflexible_gp_ref_p", "(", ")", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "loongarch_14bit_shifted_offset_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "struct", "loongarch_address_info", "addr", ";", "return", "(", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG", "&&", "CONST_INT_P", "(", "addr", ".", "offset", ")", "&&", "LARCH_16BIT_OFFSET_P", "(", "INTVAL", "(", "addr", ".", "offset", ")", ")", "&&", "LARCH_SHIFT_2_OFFSET_P", "(", "INTVAL", "(", "addr", ".", "offset", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "address", "with", "a", "14-bit", "offset", "shifted", "2", ".", "MODE", "is", "the", "mode", "of", "the", "value", "being", "accessed", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "void", "arm_option_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "int", "flags", "=", "ptr", "->", "x_target_flags", ";", "const", "char", "*", "fpu_name", ";", "fpu_name", "=", "(", "ptr", "->", "x_arm_fpu_index", "==", "TARGET_FPU_auto", "?", "\"auto\"", ":", "all_fpus", "[", "ptr", "->", "x_arm_fpu_index", "]", ".", "name", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected isa %s\\n\"", ",", "indent", ",", "\"\"", ",", "TARGET_THUMB2_P", "(", "flags", ")", "?", "\"thumb2\"", ":", "TARGET_THUMB_P", "(", "flags", ")", "?", "\"thumb1\"", ":", "\"arm\"", ")", ";", "if", "(", "ptr", "->", "x_arm_arch_string", ")", "fprintf", "(", "file", ",", "\"%*sselected architecture %s\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "x_arm_arch_string", ")", ";", "if", "(", "ptr", "->", "x_arm_cpu_string", ")", "fprintf", "(", "file", ",", "\"%*sselected CPU %s\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "x_arm_cpu_string", ")", ";", "if", "(", "ptr", "->", "x_arm_tune_string", ")", "fprintf", "(", "file", ",", "\"%*sselected tune %s\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "x_arm_tune_string", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected fpu %s\\n\"", ",", "indent", ",", "\"\"", ",", "fpu_name", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_PRINT", "." ]

[ "arm", "\"auto\"", "\"%*sselected isa %s\\n\"", "\"\"", "\"thumb2\"", "\"thumb1\"", "\"arm\"", "\"%*sselected architecture %s\\n\"", "\"\"", "\"%*sselected CPU %s\\n\"", "\"\"", "\"%*sselected tune %s\\n\"", "\"\"", "\"%*sselected fpu %s\\n\"", "\"\"" ]

[]

[ "<s>", "bool", "CAHPInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "bool", "ShouldSwap", "=", "false", ";", "switch", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "case", "CAHP", "::", "BEQ", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BNE", ")", ";", "break", ";", "case", "CAHP", "::", "BNE", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BEQ", ")", ";", "break", ";", "case", "CAHP", "::", "BLT", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BLE", ")", ";", "ShouldSwap", "=", "true", ";", "break", ";", "case", "CAHP", "::", "BLE", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BLT", ")", ";", "ShouldSwap", "=", "true", ";", "break", ";", "case", "CAHP", "::", "BLTU", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BLEU", ")", ";", "ShouldSwap", "=", "true", ";", "break", ";", "case", "CAHP", "::", "BLEU", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "CAHP", "::", "BLTU", ")", ";", "ShouldSwap", "=", "true", ";", "break", ";", "}", "if", "(", "ShouldSwap", ")", "{", "using", "std", "::", "swap", ";", "swap", "(", "Cond", "[", "1", "]", ",", "Cond", "[", "2", "]", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "3", "\"Invalid branch condition!\"", "0", "CAHP::BEQ", "0", "CAHP::BNE", "CAHP::BNE", "0", "CAHP::BEQ", "CAHP::BLT", "0", "CAHP::BLE", "CAHP::BLE", "0", "CAHP::BLT", "CAHP::BLTU", "0", "CAHP::BLEU", "CAHP::BLEU", "0", "CAHP::BLTU", "1", "2" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "EVT", "VT", ";", "SDValue", "Ptr", ";", "unsigned", "Align", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "LD", "->", "getAlignment", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Align", "=", "ST", "->", "getAlignment", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "isLegal", "=", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "getMVEIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "Align", ",", "isSEXTLoad", ",", "Subtarget", "->", "isLittle", "(", ")", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "{", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "}", "if", "(", "!", "isLegal", ")", "return", "false", ";", "AM", "=", "isInc", "?", "ISD", "::", "PRE_INC", ":", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ARM", "ISD::PRE_INC", "ISD::PRE_DEC" ]

[]

[ "<s>", "bool", "cris_constant_index_p", "(", "const_rtx", "x", ")", "{", "return", "(", "CRIS_CONSTANT_P", "(", "x", ")", "&&", "(", "!", "flag_pic", "||", "cris_valid_pic_const", "(", "x", ",", "true", ")", ")", ")", ";", "}", "</s>" ]

[ "No", "symbol", "can", "be", "used", "as", "an", "index", "(", "or", "more", "correct", ",", "as", "a", "base", ")", "together", "with", "a", "register", "with", "PIC", ";", "the", "PIC", "register", "must", "be", "there", "." ]

[ "cris" ]

[]

[ "<s>", "int", "sparc_split_reg_mem_legitimate", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "gcc_assert", "(", "reload_completed", ")", ";", "if", "(", "!", "offsettable_memref_p", "(", "mem", ")", ")", "return", "0", ";", "if", "(", "(", "REGNO", "(", "reg", ")", "%", "2", ")", "==", "0", "&&", "mem_min_alignment", "(", "mem", ",", "8", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "REG", "and", "MEM", "are", "legitimate", "enough", "to", "allow", "the", "various", "MEM", "<", "--", ">", "REG", "splits", "to", "be", "run", "." ]

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

[]

[ "<s>", "bool", "X86AsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Ops", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "VMOVZPQILo2PQIrr", ":", "case", "X86", "::", "VMOVAPDrr", ":", "case", "X86", "::", "VMOVAPDYrr", ":", "case", "X86", "::", "VMOVAPSrr", ":", "case", "X86", "::", "VMOVAPSYrr", ":", "case", "X86", "::", "VMOVDQArr", ":", "case", "X86", "::", "VMOVDQAYrr", ":", "case", "X86", "::", "VMOVDQUrr", ":", "case", "X86", "::", "VMOVDQUYrr", ":", "case", "X86", "::", "VMOVUPDrr", ":", "case", "X86", "::", "VMOVUPDYrr", ":", "case", "X86", "::", "VMOVUPSrr", ":", "case", "X86", "::", "VMOVUPSYrr", ":", "{", "if", "(", "X86II", "::", "isX86_64ExtendedReg", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "||", "!", "X86II", "::", "isX86_64ExtendedReg", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "unsigned", "NewOpc", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode\"", ")", ";", "case", "X86", "::", "VMOVZPQILo2PQIrr", ":", "NewOpc", "=", "X86", "::", "VMOVPQI2QIrr", ";", "break", ";", "case", "X86", "::", "VMOVAPDrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPDYrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPDYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPSrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPSrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPSYrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPSYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQArr", ":", "NewOpc", "=", "X86", "::", "VMOVDQArr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQAYrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQAYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQUrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQUrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQUYrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQUYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPDrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPDYrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPDYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPSrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPSrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPSYrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPSYrr_REV", ";", "break", ";", "}", "Inst", ".", "setOpcode", "(", "NewOpc", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "VMOVSDrr", ":", "case", "X86", "::", "VMOVSSrr", ":", "{", "if", "(", "X86II", "::", "isX86_64ExtendedReg", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "||", "!", "X86II", "::", "isX86_64ExtendedReg", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "unsigned", "NewOpc", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode\"", ")", ";", "case", "X86", "::", "VMOVSDrr", ":", "NewOpc", "=", "X86", "::", "VMOVSDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVSSrr", ":", "NewOpc", "=", "X86", "::", "VMOVSSrr_REV", ";", "break", ";", "}", "Inst", ".", "setOpcode", "(", "NewOpc", ")", ";", "return", "true", ";", "}", "}", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "X86", "X86", "X86::VMOVZPQILo2PQIrr", "X86::VMOVAPDrr", "X86::VMOVAPDYrr", "X86::VMOVAPSrr", "X86::VMOVAPSYrr", "X86::VMOVDQArr", "X86::VMOVDQAYrr", "X86::VMOVDQUrr", "X86::VMOVDQUYrr", "X86::VMOVUPDrr", "X86::VMOVUPDYrr", "X86::VMOVUPSrr", "X86::VMOVUPSYrr", "X86II::isX86_64ExtendedReg", "0", "X86II::isX86_64ExtendedReg", "1", "\"Invalid opcode\"", "X86::VMOVZPQILo2PQIrr", "X86::VMOVPQI2QIrr", "X86::VMOVAPDrr", "X86::VMOVAPDrr_REV", "X86::VMOVAPDYrr", "X86::VMOVAPDYrr_REV", "X86::VMOVAPSrr", "X86::VMOVAPSrr_REV", "X86::VMOVAPSYrr", "X86::VMOVAPSYrr_REV", "X86::VMOVDQArr", "X86::VMOVDQArr_REV", "X86::VMOVDQAYrr", "X86::VMOVDQAYrr_REV", "X86::VMOVDQUrr", "X86::VMOVDQUrr_REV", "X86::VMOVDQUYrr", "X86::VMOVDQUYrr_REV", "X86::VMOVUPDrr", "X86::VMOVUPDrr_REV", "X86::VMOVUPDYrr", "X86::VMOVUPDYrr_REV", "X86::VMOVUPSrr", "X86::VMOVUPSrr_REV", "X86::VMOVUPSYrr", "X86::VMOVUPSYrr_REV", "X86::VMOVSDrr", "X86::VMOVSSrr", "X86II::isX86_64ExtendedReg", "0", "X86II::isX86_64ExtendedReg", "2", "\"Invalid opcode\"", "X86::VMOVSDrr", "X86::VMOVSDrr_REV", "X86::VMOVSSrr", "X86::VMOVSSrr_REV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "getTargetMachine", "(", ")", ".", "Options", ".", "DisableTailCalls", ")", "return", "false", ";", "CallSite", "CS", "(", "CI", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "CS", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "IsTailCallConvention", "(", "CalleeCC", ")", "&&", "!", "IsCCallConvention", "(", "CalleeCC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "rtx", "rs6000_internal_arg_pointer", "(", "void", ")", "{", "if", "(", "flag_split_stack", "&&", "(", "lookup_attribute", "(", "\"no_split_stack\"", ",", "DECL_ATTRIBUTES", "(", "cfun", "->", "decl", ")", ")", "==", "NULL", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "==", "NULL_RTX", ")", "{", "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "1", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "pat", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "rtx", "ret", "=", "plus_constant", "(", "Pmode", ",", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ")", ";", "return", "copy_to_reg", "(", "ret", ")", ";", "}", "return", "virtual_incoming_args_rtx", ";", "}", "</s>" ]

[ "Return", "the", "internal", "arg", "pointer", "used", "for", "function", "incoming", "arguments", ".", "When", "-fsplit-stack", ",", "the", "arg", "pointer", "is", "r12", "so", "we", "need", "to", "copy", "it", "to", "a", "pseudo", "in", "order", "for", "it", "to", "be", "preserved", "over", "calls", "and", "suchlike", ".", "We", "'d", "really", "like", "to", "use", "a", "pseudo", "here", "for", "the", "internal", "arg", "pointer", "but", "data-flow", "analysis", "is", "not", "prepared", "to", "accept", "pseudos", "as", "live", "at", "the", "beginning", "of", "a", "function", "." ]

[ "rs6000", "\"no_split_stack\"", "1", "12" ]

[]

[ "<s>", "static", "wasm", "::", "ValType", "getType", "(", "const", "TargetRegisterClass", "*", "RC", ")", "{", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "return", "wasm", "::", "ValType", "::", "I32", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "return", "wasm", "::", "ValType", "::", "I64", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "return", "wasm", "::", "ValType", "::", "F32", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "return", "wasm", "::", "ValType", "::", "F64", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "return", "wasm", "::", "ValType", "::", "V128", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXTERNREFRegClass", ")", "return", "wasm", "::", "ValType", "::", "EXTERNREF", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "FUNCREFRegClass", ")", "return", "wasm", "::", "ValType", "::", "FUNCREF", ";", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "WebAssembly", "wasm::ValType", "WebAssembly::I32RegClass", "wasm::ValType", "WebAssembly::I64RegClass", "wasm::ValType", "WebAssembly::F32RegClass", "wasm::ValType", "WebAssembly::F64RegClass", "wasm::ValType", "WebAssembly::V128RegClass", "wasm::ValType", "WebAssembly::EXTERNREFRegClass", "wasm::ValType", "WebAssembly::FUNCREFRegClass", "wasm::ValType", "\"Unexpected register class\"" ]

[]

[ "<s>", "static", "bool", "bfin_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", "||", "size", "==", "-", "1", ";", "}", "</s>" ]

[ "Decide", "whether", "a", "type", "should", "be", "returned", "in", "memory", "(", "true", ")", "or", "in", "a", "register", "(", "false", ")", ".", "This", "is", "called", "by", "the", "macro", "RETURN_IN_MEMORY", "." ]

[ "bfin", "2", "1" ]

[]

[ "<s>", "bool", "TMS320C64XTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", ")", "{", "bool", "wantScheduleForm", ";", "switch", "(", "ClusterOpt", ")", "{", "default", ":", "wantScheduleForm", "=", "false", ";", "break", ";", "case", "ClusterUAS", ":", "case", "ClusterUAS_none", ":", "case", "ClusterUAS_rand", ":", "case", "ClusterUAS_mwp", ":", "wantScheduleForm", "=", "true", ";", "break", ";", "}", "if", "(", "Subtarget", ".", "enableClusterAssignment", "(", ")", ")", "{", "if", "(", "wantScheduleForm", ")", "PM", ".", "add", "(", "createTMS320C64XBranchDelayExpander", "(", "*", "this", ")", ")", ";", "PM", ".", "add", "(", "createTMS320C64XClusterAssignment", "(", "*", "this", ",", "ClusterOpt", ")", ")", ";", "if", "(", "wantScheduleForm", ")", "PM", ".", "add", "(", "createTMS320C64XBranchDelayReducer", "(", "*", "this", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X", "TMS320C64X" ]

[]