Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "rtx_code_label", "*", "mips16_add_constant", "(", "struct", "mips16_constant_pool", "*", "pool", ",", "rtx", "value", ",", "machine_mode", "mode", ")", "{", "struct", "mips16_constant", "*", "*", "p", ",", "*", "c", ";", "bool", "first_of_size_p", ";", "first_of_size_p", "=", "true", ";", "for", "(", "p", "=", "&", "pool", "->", "first", ";", "*", "p", "!=", "0", ";", "p", "=", "&", "(", "*", "p", ")", "->", "next", ")", "{", "if", "(", "mode", "==", "(", "*", "p", ")", "->", "mode", "&&", "rtx_equal_p", "(", "value", ",", "(", "*", "p", ")", "->", "value", ")", ")", "return", "(", "*", "p", ")", "->", "label", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "GET_MODE_SIZE", "(", "(", "*", "p", ")", "->", "mode", ")", ")", "break", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "GET_MODE_SIZE", "(", "(", "*", "p", ")", "->", "mode", ")", ")", "first_of_size_p", "=", "false", ";", "}", "if", "(", "pool", "->", "first", "==", "0", ")", "pool", "->", "highest_address", "=", "pool", "->", "insn_address", "-", "(", "UNITS_PER_WORD", "-", "2", ")", "+", "0x8000", ";", "pool", "->", "highest_address", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "first_of_size_p", ")", "pool", "->", "highest_address", "-=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "c", "=", "XNEW", "(", "struct", "mips16_constant", ")", ";", "c", "->", "value", "=", "value", ";", "c", "->", "mode", "=", "mode", ";", "c", "->", "label", "=", "gen_label_rtx", "(", ")", ";", "c", "->", "next", "=", "*", "p", ";", "*", "p", "=", "c", ";", "return", "c", "->", "label", ";", "}", "</s>" ]

[ "Add", "constant", "VALUE", "to", "POOL", "and", "return", "its", "label", ".", "MODE", "is", "the", "value", "'s", "mode", "(", "used", "for", "CONST_INTs", ",", "etc", ".", ")", "." ]

[ "mips", "0", "0", "2", "0x8000", "1" ]

[]

[ "<s>", "static", "rtx", "sparc_function_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "sparc_function_arg_1", "(", "cum", ",", "arg", ",", "false", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_FUNCTION_ARG", "target", "hook", "." ]

[ "sparc" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "performDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "performCMovFPCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "performADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "performSUBCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "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", "." ]

[ "Mips", "Mips", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "MipsISD::CMovFP_F", "MipsISD::CMovFP_T", "ISD::AND", "ISD::OR", "ISD::ADD", "ISD::SHL", "ISD::SUB" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "||", "hasFP", "(", "MF", ")", ")", "return", "FramePtr", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "const", "char", "*", "Cpu0TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Cpu0ISD", "::", "JmpLink", ":", "return", "\"Cpu0ISD::JmpLink\"", ";", "case", "Cpu0ISD", "::", "TailCall", ":", "return", "\"Cpu0ISD::TailCall\"", ";", "case", "Cpu0ISD", "::", "Hi", ":", "return", "\"Cpu0ISD::Hi\"", ";", "case", "Cpu0ISD", "::", "Lo", ":", "return", "\"Cpu0ISD::Lo\"", ";", "case", "Cpu0ISD", "::", "GPRel", ":", "return", "\"Cpu0ISD::GPRel\"", ";", "case", "Cpu0ISD", "::", "Ret", ":", "return", "\"Cpu0ISD::Ret\"", ";", "case", "Cpu0ISD", "::", "EH_RETURN", ":", "return", "\"Cpu0ISD::EH_RETURN\"", ";", "case", "Cpu0ISD", "::", "DivRem", ":", "return", "\"Cpu0ISD::DivRem\"", ";", "case", "Cpu0ISD", "::", "DivRemU", ":", "return", "\"Cpu0ISD::DivRemU\"", ";", "case", "Cpu0ISD", "::", "Wrapper", ":", "return", "\"Cpu0ISD::Wrapper\"", ";", "case", "Cpu0ISD", "::", "Sync", ":", "return", "\"Cpu0ISD::Sync\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0ISD::JmpLink", "\"Cpu0ISD::JmpLink\"", "Cpu0ISD::TailCall", "\"Cpu0ISD::TailCall\"", "Cpu0ISD::Hi", "\"Cpu0ISD::Hi\"", "Cpu0ISD::Lo", "\"Cpu0ISD::Lo\"", "Cpu0ISD::GPRel", "\"Cpu0ISD::GPRel\"", "Cpu0ISD::Ret", "\"Cpu0ISD::Ret\"", "Cpu0ISD::EH_RETURN", "\"Cpu0ISD::EH_RETURN\"", "Cpu0ISD::DivRem", "\"Cpu0ISD::DivRem\"", "Cpu0ISD::DivRemU", "\"Cpu0ISD::DivRemU\"", "Cpu0ISD::Wrapper", "\"Cpu0ISD::Wrapper\"", "Cpu0ISD::Sync", "\"Cpu0ISD::Sync\"" ]

[]

[ "<s>", "void", "rs6000_secondary_reload_gpr", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "int", "regno", "=", "true_regnum", "(", "reg", ")", ";", "enum", "reg_class", "rclass", ";", "rtx", "addr", ";", "rtx", "scratch_or_premodify", "=", "scratch", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "fprintf", "(", "stderr", ",", "\"reg:\\n\"", ")", ";", "debug_rtx", "(", "reg", ")", ";", "fprintf", "(", "stderr", ",", "\"mem:\\n\"", ")", ";", "debug_rtx", "(", "mem", ")", ";", "fprintf", "(", "stderr", ",", "\"scratch:\\n\"", ")", ";", "debug_rtx", "(", "scratch", ")", ";", "}", "gcc_assert", "(", "regno", ">=", "0", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "gcc_assert", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "scratch_or_premodify", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "scratch_or_premodify", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", ";", "rs6000_emit_move", "(", "scratch_or_premodify", ",", "addr", ",", "Pmode", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch_or_premodify", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Convert", "reloads", "involving", "64-bit", "gprs", "and", "misaligned", "offset", "addressing", ",", "or", "multiple", "32-bit", "gprs", "and", "offsets", "that", "are", "too", "large", ",", "to", "use", "indirect", "addressing", "." ]

[ "rs6000", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", "\"store\"", "\"load\"", "\"reg:\\n\"", "\"mem:\\n\"", "\"scratch:\\n\"", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "arc_init", "(", "void", ")", "{", "char", "*", "tmp", ";", "if", "(", "arc_cpu_string", "==", "0", "||", "!", "strcmp", "(", "arc_cpu_string", ",", "\"base\"", ")", ")", "{", "arc_cpu_string", "=", "\"base\"", ";", "arc_cpu_type", "=", "0", ";", "arc_mangle_cpu", "=", "NULL", ";", "}", "else", "if", "(", "ARC_EXTENSION_CPU", "(", "arc_cpu_string", ")", ")", ";", "else", "{", "error", "(", "\"bad value (%s) for -mcpu switch\"", ",", "arc_cpu_string", ")", ";", "arc_cpu_string", "=", "\"base\"", ";", "arc_cpu_type", "=", "0", ";", "arc_mangle_cpu", "=", "NULL", ";", "}", "arc_text_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_text_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_text_string", ")", ";", "arc_data_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_data_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_data_string", ")", ";", "arc_rodata_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_rodata_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_rodata_string", ")", ";", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'~'", "]", "=", "1", ";", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "arc", "0", "\"base\"", "\"base\"", "0", "\"bad value (%s) for -mcpu switch\"", "\"base\"", "0", "1", "1", "1", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "bool", "MustSaveTOC", "=", "FI", "->", "mustSaveTOC", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "CRSpilled", "=", "false", ";", "MachineInstrBuilder", "CRMIB", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "bool", "IsCRField", "=", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "bool", "IsLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "IsLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "CRSpilled", "&&", "IsCRField", ")", "{", "CRMIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "continue", ";", "}", "if", "(", "(", "Reg", "==", "PPC", "::", "X2", "||", "Reg", "==", "PPC", "::", "R2", ")", "&&", "MustSaveTOC", ")", "continue", ";", "if", "(", "IsCRField", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "FuncInfo", "->", "addMustSaveCR", "(", "Reg", ")", ";", "}", "else", "{", "CRSpilled", "=", "true", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "CRMIB", "=", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "R12", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "CRMIB", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "addFrameReference", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "R12", ",", "getKillRegState", "(", "true", ")", ")", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ")", ";", "}", "}", "else", "{", "if", "(", "CSI", "[", "i", "]", ".", "isSpilledToReg", "(", ")", ")", "{", "NumPESpillVSR", "++", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MTVSRD", ")", ",", "CSI", "[", "i", "]", ".", "getDstReg", "(", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR4", "PPC::X2", "PPC::R2", "PPC", "PPC", "PPC", "PPC::MFCR", "PPC::R12", "PPC::STW", "PPC::R12", "PPC::MTVSRD" ]

[]

[ "<s>", "void", "ix86_expand_truncdf_32", "(", "rtx", "operand0", ",", "rtx", "operand1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "mask", ",", "TWO52", ",", "one", ",", "res", ",", "smask", ",", "tmp", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "res", ",", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "smask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "tmp", ",", "TWO52", ",", "tmp", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconst1", ",", "mode", ")", ")", ";", "mask", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "res", ",", "xa", ",", "false", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mask", ",", "gen_rtx_AND", "(", "mode", ",", "mask", ",", "one", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "res", ",", "mask", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "ix86_sse_copysign_to_positive", "(", "res", ",", "res", ",", "force_reg", "(", "mode", ",", "operand1", ")", ",", "smask", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "trunc", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

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

[]

[ "<s>", "void", "s390_expand_atomic", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ",", "bool", "after", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmp", ";", "rtx", "new_rtx", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "orig", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "csloop", "=", "gen_label_rtx", "(", ")", ";", "gcc_assert", "(", "!", "target", "||", "register_operand", "(", "target", ",", "VOIDmode", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "code", "==", "SET", "&&", "MEM_P", "(", "val", ")", ")", ")", "val", "=", "s390_expand_mask_and_shift", "(", "val", ",", "mode", ",", "ac", ".", "shift", ")", ";", "if", "(", "code", "==", "PLUS", "||", "code", "==", "MINUS", ")", "emit_move_insn", "(", "orig", ",", "val", ")", ";", "else", "if", "(", "code", "==", "MULT", "||", "code", "==", "AND", ")", "val", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "val", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cmp", "=", "force_reg", "(", "SImode", ",", "ac", ".", "memsi", ")", ";", "emit_label", "(", "csloop", ")", ";", "emit_move_insn", "(", "new_rtx", ",", "cmp", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "orig", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "case", "SET", ":", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "val", ")", ")", "store_bit_field", "(", "new_rtx", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "0", ",", "0", ",", "SImode", ",", "val", ",", "false", ")", ";", "else", "{", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "new_rtx", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "s390_emit_jump", "(", "csloop", ",", "s390_emit_compare_and_swap", "(", "NE", ",", "cmp", ",", "ac", ".", "memsi", ",", "cmp", ",", "new_rtx", ",", "CCZ1mode", ")", ")", ";", "if", "(", "target", ")", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "after", "?", "new_rtx", ":", "cmp", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "operation", "CODE", "of", "mode", "MODE", ".", "MEM", "is", "the", "memory", "location", "and", "VAL", "the", "value", "to", "play", "with", ".", "If", "AFTER", "is", "true", "then", "store", "the", "the", "value", "MEM", "holds", "after", "the", "operation", ",", "if", "AFTER", "is", "false", "then", "store", "the", "value", "MEM", "holds", "before", "the", "operation", ".", "If", "TARGET", "is", "zero", "then", "discard", "that", "value", ",", "else", "store", "it", "to", "TARGET", "." ]

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

[]

[ "<s>", "static", "bool", "s390_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XVECLEN", "(", "x", ",", "0", ")", "==", "1", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOTENT", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@GOTENT\"", ")", ";", "return", "true", ";", "case", "UNSPEC_GOT", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@GOT\"", ")", ";", "return", "true", ";", "case", "UNSPEC_GOTOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@GOTOFF\"", ")", ";", "return", "true", ";", "case", "UNSPEC_PLT31", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@PLT\"", ")", ";", "return", "true", ";", "case", "UNSPEC_PLTOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@PLTOFF\"", ")", ";", "return", "true", ";", "case", "UNSPEC_TLSGD", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@TLSGD\"", ")", ";", "return", "true", ";", "case", "UNSPEC_TLSLDM", ":", "assemble_name", "(", "file", ",", "get_some_local_dynamic_name", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"@TLSLDM\"", ")", ";", "return", "true", ";", "case", "UNSPEC_DTPOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@DTPOFF\"", ")", ";", "return", "true", ";", "case", "UNSPEC_NTPOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@NTPOFF\"", ")", ";", "return", "true", ";", "case", "UNSPEC_GOTNTPOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@GOTNTPOFF\"", ")", ";", "return", "true", ";", "case", "UNSPEC_INDNTPOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"@INDNTPOFF\"", ")", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XVECLEN", "(", "x", ",", "0", ")", "==", "2", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_POOL_OFFSET", ":", "x", "=", "gen_rtx_MINUS", "(", "GET_MODE", "(", "x", ")", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ",", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Output", "machine-dependent", "UNSPECs", "occurring", "in", "address", "constant", "X", "in", "assembler", "syntax", "to", "stdio", "stream", "FILE", ".", "Returns", "true", "if", "the", "constant", "X", "could", "be", "recognized", ",", "false", "otherwise", "." ]

[ "s390", "0", "1", "1", "0", "0", "\"@GOTENT\"", "0", "0", "\"@GOT\"", "0", "0", "\"@GOTOFF\"", "0", "0", "\"@PLT\"", "0", "0", "\"@PLTOFF\"", "0", "0", "\"@TLSGD\"", "\"@TLSLDM\"", "0", "0", "\"@DTPOFF\"", "0", "0", "\"@NTPOFF\"", "0", "0", "\"@GOTNTPOFF\"", "0", "0", "\"@INDNTPOFF\"", "0", "2", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "is_store_insn", "(", "rtx", "insn", ",", "rtx", "*", "str_mem", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "return", "is_store_insn1", "(", "PATTERN", "(", "insn", ")", ",", "str_mem", ")", ";", "}", "</s>" ]

[ "Determine", "if", "INSN", "stores", "to", "memory", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AVR", "::", "LDDRdPtrQ", ":", "case", "AVR", "::", "LDDWRdYQ", ":", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::LDDRdPtrQ", "AVR::LDDWRdYQ", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AS", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "v64i8", ":", "case", "MVT", "::", "v128i8", ":", "case", "MVT", "::", "v256i8", ":", "case", "MVT", "::", "v32i16", ":", "case", "MVT", "::", "v64i16", ":", "case", "MVT", "::", "v128i16", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v32i32", ":", "case", "MVT", "::", "v64i32", ":", "case", "MVT", "::", "v8i64", ":", "case", "MVT", "::", "v16i64", ":", "case", "MVT", "::", "v32i64", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "MVT::v64i8", "MVT::v128i8", "MVT::v256i8", "MVT::v32i16", "MVT::v64i16", "MVT::v128i16", "MVT::v16i32", "MVT::v32i32", "MVT::v64i32", "MVT::v8i64", "MVT::v16i64", "MVT::v32i64" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "MFCR8pseud", ":", "PPC", "::", "MFCRpseud", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "{", "unsigned", "Reg1", "=", "Reg", ";", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "RLWINM8", ":", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg1", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getEncodingValue", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "}", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "0", "PPC::MFCR8pseud", "PPC::MFCRpseud", "0", "PPC::CR0", "PPC::RLWINM8", "PPC::RLWINM", "4", "0", "31", "PPC::STW8", "PPC::STW" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "int", "FrameIndex", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "if", "(", "NoFusing", ")", "return", "nullptr", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", "&&", "hasPartialRegUpdate", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "nullptr", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Size", "=", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Alignment", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "if", "(", "!", "RI", ".", "needsStackRealignment", "(", "MF", ")", ")", "Alignment", "=", "std", "::", "min", "(", "Alignment", ",", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ")", ";", "if", "(", "Ops", ".", "size", "(", ")", "==", "2", "&&", "Ops", "[", "0", "]", "==", "0", "&&", "Ops", "[", "1", "]", "==", "1", ")", "{", "unsigned", "NewOpc", "=", "0", ";", "unsigned", "RCSize", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "X86", "::", "TEST8rr", ":", "NewOpc", "=", "X86", "::", "CMP8ri", ";", "RCSize", "=", "1", ";", "break", ";", "case", "X86", "::", "TEST16rr", ":", "NewOpc", "=", "X86", "::", "CMP16ri8", ";", "RCSize", "=", "2", ";", "break", ";", "case", "X86", "::", "TEST32rr", ":", "NewOpc", "=", "X86", "::", "CMP32ri8", ";", "RCSize", "=", "4", ";", "break", ";", "case", "X86", "::", "TEST64rr", ":", "NewOpc", "=", "X86", "::", "CMP64ri8", ";", "RCSize", "=", "8", ";", "break", ";", "}", "if", "(", "Size", "<", "RCSize", ")", "return", "nullptr", ";", "MI", ".", "setDesc", "(", "get", "(", "NewOpc", ")", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "}", "else", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "nullptr", ";", "return", "foldMemoryOperandImpl", "(", "MF", ",", "MI", ",", "Ops", "[", "0", "]", ",", "MachineOperand", "::", "CreateFI", "(", "FrameIndex", ")", ",", "InsertPt", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "X86", "X86", "2", "0", "0", "1", "1", "0", "0", "X86::TEST8rr", "X86::CMP8ri", "1", "X86::TEST16rr", "X86::CMP16ri8", "2", "X86::TEST32rr", "X86::CMP32ri8", "4", "X86::TEST64rr", "X86::CMP64ri8", "8", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "rs6000_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ")", "{", "ptr", "->", "x_rs6000_isa_flags", "=", "opts", "->", "x_rs6000_isa_flags", ";", "ptr", "->", "x_rs6000_isa_flags_explicit", "=", "opts", "->", "x_rs6000_isa_flags_explicit", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "int", "sparc_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "bool", "need_memory", "=", "false", ";", "if", "(", "from", "==", "NO_REGS", "||", "to", "==", "NO_REGS", ")", "return", "100", ";", "if", "(", "from", "==", "FPCC_REGS", "||", "to", "==", "FPCC_REGS", ")", "need_memory", "=", "true", ";", "else", "if", "(", "(", "FP_REG_CLASS_P", "(", "from", ")", "&&", "general_or_i64_p", "(", "to", ")", ")", "||", "(", "general_or_i64_p", "(", "from", ")", "&&", "FP_REG_CLASS_P", "(", "to", ")", ")", ")", "{", "if", "(", "TARGET_VIS3", ")", "{", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", "==", "8", "||", "size", "==", "4", ")", "{", "if", "(", "!", "TARGET_ARCH32", "||", "size", "==", "4", ")", "return", "4", ";", "else", "return", "6", ";", "}", "}", "need_memory", "=", "true", ";", "}", "if", "(", "need_memory", ")", "{", "if", "(", "sparc_cpu", "==", "PROCESSOR_ULTRASPARC", "||", "sparc_cpu", "==", "PROCESSOR_ULTRASPARC3", "||", "sparc_cpu", "==", "PROCESSOR_NIAGARA", "||", "sparc_cpu", "==", "PROCESSOR_NIAGARA2", "||", "sparc_cpu", "==", "PROCESSOR_NIAGARA3", "||", "sparc_cpu", "==", "PROCESSOR_NIAGARA4", "||", "sparc_cpu", "==", "PROCESSOR_NIAGARA7", "||", "sparc_cpu", "==", "PROCESSOR_M8", ")", "return", "12", ";", "return", "6", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", "." ]

[ "sparc", "100", "8", "4", "4", "4", "6", "12", "6", "2" ]

[]

[ "<s>", "void", "HSAILImageHandles", "::", "finalize", "(", ")", "{", "char", "buf", "[", "16", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "HSAILSamplers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "if", "(", "getSamplerSymbol", "(", "i", ")", ".", "empty", "(", ")", ")", "{", "sprintf", "(", "buf", ",", "\"%s%u\"", ",", "\"__Samp\"", ",", "index", ")", ";", "HSAILSamplers", "[", "i", "]", "->", "setSym", "(", "buf", ")", ";", "index", "++", ";", "}", "}", "}", "</s>" ]

[ "Analyze", "the", "strings", "and", "build", "the", "final", "table", "." ]

[ "HSAIL", "HSAIL", "16", "0", "HSAIL", "\"%s%u\"", "\"__Samp\"", "HSAIL" ]

[]

[ "<s>", "bool", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "override", "{", "return", "SrcAS", "<", "256", "&&", "DestAS", "<", "256", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

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

[]

[ "<s>", "inline", "void", "function_expander", "::", "add_all_one_mask_operand", "(", "machine_mode", "mode", ")", "{", "add_input_operand", "(", "mode", ",", "CONSTM1_RTX", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Since", "we", "may", "normalize", "vop/vop_tu/vop_m/vop_tumu", "..", "into", "a", "single", "patter", ".", "We", "add", "a", "fake", "all", "true", "mask", "for", "the", "intrinsics", "that", "do", "n't", "need", "a", "real", "mask", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "xstormy16_expand_move", "(", "enum", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "rtx", "dest_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "dest_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "Pmode", ",", "dest_reg", ",", "dest_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "16", ")", ")", ";", "dest", "=", "gen_rtx_MEM", "(", "mode", ",", "dest_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "src_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "Pmode", ",", "src_reg", ",", "src_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "16", ")", ")", ";", "src", "=", "gen_rtx_MEM", "(", "mode", ",", "src_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "!=", "CONST_INT", "||", "!", "xstormy16_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "dest", ",", "0", ")", ",", "0", ")", ")", "&&", "!", "xstormy16_below100_operand", "(", "dest", ",", "mode", ")", "&&", "GET_CODE", "(", "src", ")", "!=", "REG", "&&", "GET_CODE", "(", "src", ")", "!=", "SUBREG", ")", "src", "=", "copy_to_mode_reg", "(", "mode", ",", "src", ")", ";", "if", "(", "reload_completed", "&&", "mode", "!=", "HImode", "&&", "mode", "!=", "QImode", ")", "{", "xstormy16_split_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "return", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "the", "'move", "'", "patterns", ".", "Emit", "insns", "to", "copy", "a", "value", "of", "mode", "MODE", "from", "SRC", "to", "DEST", "." ]

[ "stormy16", "0", "0", "0", "1", "16", "2", "0", "0", "0", "1", "16", "2", "0", "0", "0" ]

[]

[ "<s>", "long", "compute_frame_size", "(", "poly_int64", "size", ")", "{", "int", "regno", ";", "if", "(", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame_laid_out", ")", "return", "cfun", "->", "machine", "->", "current_frame_size", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "size", "+=", "(", "1", "*", "UNITS_PER_WORD", ")", ";", "cfun", "->", "machine", "->", "callee_save_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "++", "regno", ")", "{", "if", "(", "xtensa_call_save_reg", "(", "regno", ")", ")", "cfun", "->", "machine", "->", "callee_save_size", "+=", "UNITS_PER_WORD", ";", "}", "cfun", "->", "machine", "->", "current_frame_size", "=", "XTENSA_STACK_ALIGN", "(", "size", "+", "cfun", "->", "machine", "->", "callee_save_size", "+", "crtl", "->", "outgoing_args_size", "+", "(", "WINDOW_SIZE", "*", "UNITS_PER_WORD", ")", ")", ";", "cfun", "->", "machine", "->", "callee_save_size", "=", "XTENSA_STACK_ALIGN", "(", "cfun", "->", "machine", "->", "callee_save_size", ")", ";", "cfun", "->", "machine", "->", "frame_laid_out", "=", "true", ";", "return", "cfun", "->", "machine", "->", "current_frame_size", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "xtensa", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "pru_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_RETVAL_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "pru" ]

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "TargetOffset", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "(", "TargetOffset", "+", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "(", "Value", "&", "Mask", ")", "<<", "TargetOffset", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "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", "." ]

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "2", "Mips::fixup_Mips_64", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "SDValue", "M680x0TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "M680x0ISD", "::", "SUBX", ":", "return", "combineSUBX", "(", "N", ",", "DAG", ")", ";", "case", "M680x0ISD", "::", "ADDX", ":", "return", "combineADDX", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "M680x0ISD", "::", "SETCC", ":", "return", "combineM680x0SetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "M680x0ISD", "::", "BRCOND", ":", "return", "combineM680x0BrCond", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "}", "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", "." ]

[ "M680x0", "M680x0", "M680x0ISD::SUBX", "M680x0ISD::ADDX", "M680x0ISD::SETCC", "M680x0", "M680x0ISD::BRCOND", "M680x0" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "HasDSPR3", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "UseTCCInDIV", "(", "false", ")", ",", "HasEVA", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "isABI_O32", "(", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "void", "i386_pe_unique_section", "(", "tree", "decl", ",", "int", "reloc", ")", "{", "int", "len", ";", "const", "char", "*", "name", ",", "*", "prefix", ";", "char", "*", "string", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "i386_pe_strip_name_encoding_full", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "prefix", "=", "\".text$\"", ";", "else", "if", "(", "decl_readonly_section", "(", "decl", ",", "reloc", ")", ")", "prefix", "=", "\".rdata$\"", ";", "else", "prefix", "=", "\".data$\"", ";", "len", "=", "strlen", "(", "name", ")", "+", "strlen", "(", "prefix", ")", ";", "string", "=", "alloca", "(", "len", "+", "1", ")", ";", "sprintf", "(", "string", ",", "\"%s%s\"", ",", "prefix", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", ",", "string", ")", ";", "}", "</s>" ]

[ "Cover", "function", "for", "UNIQUE_SECTION", "." ]

[ "i386", "\".text$\"", "\".rdata$\"", "\".data$\"", "1", "\"%s%s\"" ]

[]

[ "<s>", "static", "int", "s390_sched_reorder", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "nreadyp", ",", "int", "clock", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "s390_tune", "==", "PROCESSOR_2097_Z10", "&&", "reload_completed", "&&", "*", "nreadyp", ">", "1", ")", "s390_z10_prevent_earlyload_conflicts", "(", "ready", ",", "nreadyp", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2827_ZEC12", "&&", "reload_completed", "&&", "*", "nreadyp", ">", "1", ")", "{", "int", "i", ";", "int", "last_index", "=", "*", "nreadyp", "-", "1", ";", "int", "max_index", "=", "-", "1", ";", "int", "max_score", "=", "-", "1", ";", "rtx_insn", "*", "tmp", ";", "for", "(", "i", "=", "last_index", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "score", ";", "if", "(", "recog_memoized", "(", "ready", "[", "i", "]", ")", "<", "0", ")", "continue", ";", "score", "=", "s390_sched_score", "(", "ready", "[", "i", "]", ")", ";", "if", "(", "score", ">", "max_score", ")", "{", "max_score", "=", "score", ";", "max_index", "=", "i", ";", "}", "}", "if", "(", "max_index", "!=", "-", "1", ")", "{", "if", "(", "max_index", "!=", "last_index", ")", "{", "tmp", "=", "ready", "[", "max_index", "]", ";", "ready", "[", "max_index", "]", "=", "ready", "[", "last_index", "]", ";", "ready", "[", "last_index", "]", "=", "tmp", ";", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: move insn %d to the top of list\\n\"", ",", "INSN_UID", "(", "ready", "[", "last_index", "]", ")", ")", ";", "}", "else", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: best insn %d already on top\\n\"", ",", "INSN_UID", "(", "ready", "[", "last_index", "]", ")", ")", ";", "}", "if", "(", "verbose", ">", "5", ")", "{", "fprintf", "(", "file", ",", "\"ready list ooo attributes - sched state: %d\\n\"", ",", "sched_state", ".", "group_state", ")", ";", "for", "(", "i", "=", "last_index", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "unsigned", "int", "sched_mask", ";", "rtx_insn", "*", "insn", "=", "ready", "[", "i", "]", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "continue", ";", "sched_mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: insn %d score: %d: \"", ",", "INSN_UID", "(", "insn", ")", ",", "s390_sched_score", "(", "insn", ")", ")", ";", "(", "(", "M", ")", "&", "sched_mask", ")", "?", "#", "ATTR", ":", "\"\"", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_CRACKED", ",", "cracked", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_EXPANDED", ",", "expanded", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_ENDGROUP", ",", "endgroup", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_GROUPALONE", ",", "groupalone", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "unsigned", "int", "unit_mask", ",", "m", "=", "1", ";", "int", "units", ",", "j", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\"(units:\"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "fprintf", "(", "file", ",", "\" u%d\"", ",", "j", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "}", "}", "return", "s390_issue_rate", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "via", "hook", "TARGET_SCHED_REORDER", "before", "issuing", "one", "insn", "from", "list", "READY", "which", "contains", "*", "NREADYP", "entries", ".", "For", "target", "z10", "it", "reorders", "load", "instructions", "to", "avoid", "early", "load", "conflicts", "in", "the", "floating", "point", "pipeline" ]

[ "s390", "1", "1", "1", "1", "1", "0", "0", "1", "5", "\";;\\t\\tBACKEND: move insn %d to the top of list\\n\"", "5", "\";;\\t\\tBACKEND: best insn %d already on top\\n\"", "5", "\"ready list ooo attributes - sched state: %d\\n\"", "0", "0", "\";;\\t\\tBACKEND: insn %d score: %d: \"", "\"\"", "1", "\"(units:\"", "0", "1", "\" u%d\"", "\")\"", "\"\\n\"" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "unsigned", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "0", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::V_MOV_B32_e32" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "Intel_OCL_BI", ")", "{", "if", "(", "IsWin64", "&&", "HasAVX", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "Is64Bit", "&&", "HasAVX", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "GHC", "||", "CC", "==", "CallingConv", "::", "HiPE", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpc", "=", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "AVR", "AVR", "AVRISD::RETI_FLAG", "AVRISD::RET_FLAG", "0", "MVT::Other" ]

[]

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

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "TPC" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "Thumb1RegisterInfo", "::", "getPointerRegClass", "(", "unsigned", "Kind", ")", "const", "{", "return", "ARM", "::", "tGPRRegisterClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "ARM", "ARM::tGPRRegisterClass" ]

[]

[ "<s>", "void", "AlphaTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "VAARG", "&&", "\"Unknown node to custom promote!\"", ")", ";", "SDValue", "Chain", ",", "DataPtr", ";", "LowerVAARG", "(", "N", ",", "Chain", ",", "DataPtr", ",", "DAG", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getLoad", "(", "N", "->", "getValueType", "(", "0", ")", ",", "dl", ",", "Chain", ",", "DataPtr", ",", "NULL", ",", "0", ",", "false", ",", "false", ",", "0", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Res", ".", "getNode", "(", ")", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "Alpha", "Alpha", "0", "MVT::i32", "ISD::VAARG", "\"Unknown node to custom promote!\"", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "init_vselect_insn", "(", "void", ")", "{", "unsigned", "i", ";", "rtx", "x", ";", "x", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "MAX_VECT_LEN", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "MAX_VECT_LEN", ";", "++", "i", ")", "XVECEXP", "(", "x", ",", "0", ",", "i", ")", "=", "const0_rtx", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "V2DFmode", ",", "gen_rtx_VEC_CONCAT", "(", "V4DFmode", ",", "const0_rtx", ",", "const0_rtx", ")", ",", "x", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "const0_rtx", ",", "x", ")", ";", "start_sequence", "(", ")", ";", "vselect_insn", "=", "emit_insn", "(", "x", ")", ";", "end_sequence", "(", ")", ";", "}", "</s>" ]

[ "Initialize", "vselect_insn", "." ]

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

[]

[ "<s>", "static", "struct", "machine_function", "*", "arm_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "func_type", "=", "ARM_FT_UNKNOWN", ";", "machine", "->", "static_chain_stack_bytes", "=", "-", "1", ";", "return", "machine", ";", "}", "</s>" ]

[ "Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]

[ "arm", "1" ]

[]

[ "<s>", "void", "TPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TPC", "::", "NOPv", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "TPC", "TPC", "TPC::NOPv" ]

[]

[ "<s>", "static", "void", "ft32_operand_lossage", "(", "const", "char", "*", "msgid", ",", "rtx", "op", ")", "{", "debug_rtx", "(", "op", ")", ";", "output_operand_lossage", "(", "\"%s\"", ",", "msgid", ")", ";", "}", "</s>" ]

[ "Emit", "an", "error", "message", "when", "we", "'re", "in", "an", "asm", ",", "and", "a", "fatal", "error", "for", "``", "normal", "''", "insns", ".", "Formatted", "output", "is", "n't", "easily", "implemented", ",", "since", "we", "use", "output_operand_lossage", "to", "output", "the", "actual", "message", "and", "handle", "the", "categorization", "of", "the", "error", "." ]

[ "ft32", "\"%s\"" ]

[]

[ "<s>", "static", "void", "avr_file_end", "(", "void", ")", "{", "if", "(", "avr_need_copy_data_p", ")", "fputs", "(", "\".global __do_copy_data\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "avr_need_clear_bss_p", ")", "fputs", "(", "\".global __do_clear_bss\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Outputs", "to", "the", "stdio", "stream", "FILE", "some", "appropriate", "text", "to", "go", "at", "the", "end", "of", "an", "assembler", "file", "." ]

[ "avr", "\".global __do_copy_data\\n\"", "\".global __do_clear_bss\\n\"" ]

[]

[ "<s>", "const", "char", "*", "thumb_unexpanded_epilogue", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "long", "live_regs_mask", "=", "0", ";", "int", "high_regs_pushed", "=", "0", ";", "int", "had_to_push_lr", ";", "int", "size", ";", "if", "(", "return_used_this_function", ")", "return", "\"\"", ";", "if", "(", "IS_NAKED", "(", "arm_current_func_type", "(", ")", ")", ")", "return", "\"\"", ";", "live_regs_mask", "=", "thumb_compute_save_reg_mask", "(", ")", ";", "high_regs_pushed", "=", "bit_count", "(", "live_regs_mask", "&", "0x0f00", ")", ";", "size", "=", "arm_size_return_regs", "(", ")", ";", "if", "(", "high_regs_pushed", ")", "{", "unsigned", "long", "mask", "=", "live_regs_mask", "&", "0xff", ";", "int", "next_hi_reg", ";", "if", "(", "size", "<=", "12", ")", "mask", "|=", "1", "<<", "3", ";", "if", "(", "size", "<=", "8", ")", "mask", "|=", "1", "<<", "2", ";", "if", "(", "mask", "==", "0", ")", "internal_error", "(", "\"no low registers available for popping high registers\"", ")", ";", "for", "(", "next_hi_reg", "=", "8", ";", "next_hi_reg", "<", "13", ";", "next_hi_reg", "++", ")", "if", "(", "live_regs_mask", "&", "(", "1", "<<", "next_hi_reg", ")", ")", "break", ";", "while", "(", "high_regs_pushed", ")", "{", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "high_regs_pushed", "--", ";", "if", "(", "high_regs_pushed", "==", "0", ")", "break", ";", "}", "mask", "&=", "(", "2", "<<", "regno", ")", "-", "1", ";", "thumb_pushpop", "(", "asm_out_file", ",", "mask", ",", "0", ",", "NULL", ",", "mask", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "regno", ")", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "next_hi_reg", ",", "regno", ")", ";", "for", "(", "next_hi_reg", "++", ";", "next_hi_reg", "<", "13", ";", "next_hi_reg", "++", ")", "if", "(", "live_regs_mask", "&", "(", "1", "<<", "next_hi_reg", ")", ")", "break", ";", "}", "}", "}", "live_regs_mask", "&=", "~", "0x0f00", ";", "}", "had_to_push_lr", "=", "(", "live_regs_mask", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", "!=", "0", ";", "live_regs_mask", "&=", "0xff", ";", "if", "(", "current_function_pretend_args_size", "==", "0", "||", "TARGET_BACKTRACE", ")", "{", "if", "(", "had_to_push_lr", ")", "live_regs_mask", "|=", "1", "<<", "PC_REGNUM", ";", "if", "(", "live_regs_mask", ")", "thumb_pushpop", "(", "asm_out_file", ",", "live_regs_mask", ",", "FALSE", ",", "NULL", ",", "live_regs_mask", ")", ";", "if", "(", "!", "had_to_push_lr", ")", "thumb_exit", "(", "asm_out_file", ",", "LR_REGNUM", ")", ";", "}", "else", "{", "if", "(", "live_regs_mask", ")", "thumb_pushpop", "(", "asm_out_file", ",", "live_regs_mask", ",", "FALSE", ",", "NULL", ",", "live_regs_mask", ")", ";", "if", "(", "had_to_push_lr", ")", "{", "if", "(", "size", ">", "12", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "IP_REGNUM", ",", "LAST_ARG_REGNUM", ")", ";", "}", "thumb_pushpop", "(", "asm_out_file", ",", "1", "<<", "LAST_ARG_REGNUM", ",", "0", ",", "NULL", ",", "1", "<<", "LAST_ARG_REGNUM", ")", ";", "if", "(", "size", ">", "12", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "LR_REGNUM", ",", "LAST_ARG_REGNUM", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tmov\\t%r, %r\\n\"", ",", "LAST_ARG_REGNUM", ",", "IP_REGNUM", ")", ";", "regno", "=", "LR_REGNUM", ";", "}", "else", "regno", "=", "LAST_ARG_REGNUM", ";", "}", "else", "regno", "=", "LR_REGNUM", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tadd\\t%r, %r, #%d\\n\"", ",", "SP_REGNUM", ",", "SP_REGNUM", ",", "current_function_pretend_args_size", ")", ";", "thumb_exit", "(", "asm_out_file", ",", "regno", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "The", "bits", "which", "are", "n't", "usefully", "expanded", "as", "rtl", "." ]

[ "arm", "0", "0", "\"\"", "\"\"", "0x0f00", "0xff", "12", "1", "3", "8", "1", "2", "0", "\"no low registers available for popping high registers\"", "8", "13", "1", "0", "1", "0", "2", "1", "0", "0", "1", "\"\\tmov\\t%r, %r\\n\"", "13", "1", "0x0f00", "1", "0", "0xff", "0", "1", "12", "\"\\tmov\\t%r, %r\\n\"", "1", "0", "1", "12", "\"\\tmov\\t%r, %r\\n\"", "\"\\tmov\\t%r, %r\\n\"", "\"\\tadd\\t%r, %r, #%d\\n\"", "\"\"" ]

[]

[ "<s>", "void", "convert_registers", "(", ")", "{", "}", "</s>" ]

[ "Generate", "copies", "from", "defs", "used", "by", "the", "chain", "but", "not", "defined", "therein", ".", "Also", "populates", "defs_map", "which", "is", "used", "later", "by", "convert_insn", "." ]

[ "i386" ]

[]

[ "<s>", "const", "uint16_t", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "(", "STI", ".", "isTargetIOS", "(", ")", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "cris_atomic_align_for_mode", "(", "machine_mode", "mode", ")", "{", "return", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "}", "</s>" ]

[ "Atomic", "types", "require", "alignment", "to", "be", "at", "least", "their", "``", "natural", "''", "size", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "isHsaAbiVersion3Or4", "(", "&", "getSTI", "(", ")", ")", ")", "{", "if", "(", "IDVal", "==", "\".amdhsa_kernel\"", ")", "return", "ParseDirectiveAMDHSAKernel", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "V3", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "else", "{", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_amdgpu_isa\"", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".amdgcn_target\"", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_lds\"", ")", "return", "ParseDirectiveAMDGPULDS", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectivePALMetadataBegin", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\".amdhsa_kernel\"", "AMDGPU::HSAMD", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amd_amdgpu_isa\"", "AMDGPU::HSAMD", "\".amdgcn_target\"", "\".amdgpu_lds\"", "AMDGPU" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "ARMBaseRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "GPRRegClass", ";", "else", "if", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "DPRRegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegClass", "ARM::GPRRegClass", "ARM::DPRRegClass", "ARM::DPRRegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

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

[ "True", "if", "the", "machine", "scheduler", "should", "disable", "the", "TLI", "preference", "for", "preRA", "scheduling", "with", "the", "source", "level", "scheduler", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "bool", "isCalleeStructRet", ",", "bool", "isCallerStructRet", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "*", "CallerF", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", "->", "getCallingConv", "(", ")", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "!", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "CCMatch", ")", "return", "false", ";", "if", "(", "isVarArg", ")", "return", "false", ";", "if", "(", "isCalleeStructRet", "||", "isCallerStructRet", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "Hexagon", "Hexagon", "ISD::OutputArg", "ISD::InputArg" ]

[]

[ "<s>", "static", "void", "sparc_conditional_register_usage", "(", "void", ")", "{", "if", "(", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_ARCH32", "&&", "fixed_regs", "[", "5", "]", ")", "fixed_regs", "[", "5", "]", "=", "1", ";", "else", "if", "(", "TARGET_ARCH64", "&&", "fixed_regs", "[", "5", "]", "==", "2", ")", "fixed_regs", "[", "5", "]", "=", "0", ";", "if", "(", "!", "TARGET_V9", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "SPARC_FIRST_V9_FP_REG", ";", "regno", "<=", "SPARC_LAST_V9_FP_REG", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "1", ";", "for", "(", "regno", "=", "SPARC_FIRST_V9_FCC_REG", "+", "1", ";", "regno", "<=", "SPARC_LAST_V9_FCC_REG", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_FPU", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "32", ";", "regno", "<", "SPARC_LAST_V9_FCC_REG", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "fixed_regs", "[", "2", "]", "==", "2", ")", "fixed_regs", "[", "2", "]", "=", "!", "TARGET_APP_REGS", ";", "if", "(", "fixed_regs", "[", "3", "]", "==", "2", ")", "fixed_regs", "[", "3", "]", "=", "!", "TARGET_APP_REGS", ";", "if", "(", "TARGET_ARCH32", "&&", "fixed_regs", "[", "4", "]", "==", "2", ")", "fixed_regs", "[", "4", "]", "=", "!", "TARGET_APP_REGS", ";", "else", "if", "(", "TARGET_CM_EMBMEDANY", ")", "fixed_regs", "[", "4", "]", "=", "1", ";", "else", "if", "(", "fixed_regs", "[", "4", "]", "==", "2", ")", "fixed_regs", "[", "4", "]", "=", "0", ";", "if", "(", "TARGET_FLAT", ")", "memset", "(", "sparc_leaf_regs", ",", "0", ",", "FIRST_PSEUDO_REGISTER", ")", ";", "if", "(", "TARGET_VIS", ")", "global_regs", "[", "SPARC_GSR_REG", "]", "=", "1", ";", "}", "</s>" ]

[ "If", "!", "TARGET_FPU", ",", "then", "make", "the", "fp", "registers", "and", "fp", "cc", "regs", "fixed", "so", "that", "they", "wo", "n't", "be", "allocated", "." ]

[ "sparc", "1", "5", "5", "1", "5", "2", "5", "0", "1", "1", "1", "32", "1", "2", "2", "2", "3", "2", "3", "4", "2", "4", "4", "1", "4", "2", "4", "0", "0", "1" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "rs6000_starting_frame_offset", "(", "void", ")", "{", "if", "(", "FRAME_GROWS_DOWNWARD", ")", "return", "0", ";", "return", "RS6000_STARTING_FRAME_OFFSET", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "Register", "LanaiMachineFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "Lanai", "::", "GPRRegClass", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::GPRRegClass" ]

[]

[ "<s>", "bool", "WebAssemblyArgumentMove", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Argument Move **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "EntryMBB", ".", "end", "(", ")", ";", "for", "(", "auto", "MII", "=", "EntryMBB", ".", "begin", "(", ")", ",", "MIE", "=", "EntryMBB", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "!", "IsArgument", "(", "MI", ")", ")", "{", "InsertPt", "=", "MII", ";", "break", ";", "}", "}", "for", "(", "auto", "I", "=", "InsertPt", ",", "E", "=", "EntryMBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "if", "(", "IsArgument", "(", "MI", ")", ")", "{", "EntryMBB", ".", "insert", "(", "InsertPt", ",", "MI", "->", "removeFromParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Argument Move **********\\n\"", "\"********** Function: \"" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Darwin PPC Assembly Printer\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Darwin PPC Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValue expects only expressions\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_PC16", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "\"getBranchTargetOpValue expects only expressions\"", "0", "Mips::fixup_Mips_PC16", "0" ]

[]

[ "<s>", "bool", "MBlazeAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "int", "ix86_mode_entry", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_entry", "(", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_entry", "(", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "entry", "." ]

[ "i386" ]

[]

[ "<s>", "static", "inline", "bool", "m32r_load_postinc_p", "(", "machine_mode", "mode", ",", "const_rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "&&", "GET_CODE", "(", "x", ")", "==", "POST_INC", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "m32r_rtx_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Is", "this", "a", "load", "and", "increment", "operation", "." ]

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

[]

[ "<s>", "bool", "MOSAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "while", "(", "(", "Count", "--", ")", ">", "0", ")", "{", "OS", "<<", "0xEA", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "0", "0xEA" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "hasVPU", "=", "false", ";", "hasSPU", "=", "false", ";", "hasLD", "=", "false", ";", "hasST", "=", "false", ";", "VPUInst", "=", "0L", ";", "SPUInst", "=", "0L", ";", "LDInst", "=", "0L", ";", "STInst", "=", "0L", ";", "LdSrcExtra", "=", "0", ";", "StSrcExtra", "=", "0", ";", "LdSwitch", "=", "0", ";", "StSwitch", "=", "0", ";", "Imm", "=", "0L", ";", "immSlotBusy", "=", "false", ";", "compress", "=", "0", ";", "inited", "=", "false", ";", "doNotCompress", "=", "false", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "TPC", "0L", "0L", "0L", "0L", "0", "0", "0", "0", "0L", "0" ]

[]

[ "<s>", "static", "bool", "v850_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "RV_REGNUM", ")", ";", "}", "</s>" ]

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

[ "v850" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "inline", "bool", "inline_secondary_memory_needed", "(", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ",", "machine_mode", "mode", ",", "int", "strict", ")", "{", "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class1", ")", "||", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class1", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class2", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class1", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class2", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "{", "gcc_assert", "(", "!", "strict", "||", "lra_in_progress", ")", ";", "return", "true", ";", "}", "if", "(", "FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "(", "MAYBE_MASK_CLASS_P", "(", "class1", ")", "!=", "MAYBE_MASK_CLASS_P", "(", "class2", ")", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", ")", "return", "true", ";", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "TARGET_SSE2", ")", "return", "true", ";", "if", "(", "(", "SSE_CLASS_P", "(", "class1", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "||", "(", "SSE_CLASS_P", "(", "class2", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "To", "optimize", "register_move_cost", "performance", ",", "allow", "inline", "variant", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "int", "pic_address_needs_scratch", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "SMALL_INT", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "an", "address", "which", "needs", "a", "temporary", "register", "when", "reloaded", "while", "generating", "PIC", "code", "." ]

[ "sparc", "0", "0", "0", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "SystemZMCAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "!=", "Count", ";", "++", "I", ")", "OW", "->", "write8", "(", "7", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "7" ]

[]

[ "<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "cost", "=", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "SUBREG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "cost", "=", "18", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "io_address_operand", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_absdata_p", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "}", "if", "(", "avr_log", ".", "address_cost", ")", "avr_edump", "(", "\"\\n%?: %d = %r\\n\"", ",", "cost", ",", "x", ")", ";", "return", "cost", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "a", "memory", "address", "." ]

[ "avr", "4", "1", "0", "0", "1", "18", "2", "2", "\"\\n%?: %d = %r\\n\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Shrink Instructions\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Shrink Instructions\"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "bool", "isDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "if", "(", "(", "isPPC64", "&&", "VT", "!=", "MVT", "::", "i64", "&&", "VT", "!=", "MVT", "::", "i32", ")", "||", "(", "!", "isPPC64", "&&", "VT", "!=", "MVT", "::", "i32", ")", ")", "report_fatal_error", "(", "\"Invalid register global variable type\"", ")", ";", "bool", "is64Bit", "=", "isPPC64", "&&", "VT", "==", "MVT", "::", "i64", ";", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r1\"", ",", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ")", ".", "Case", "(", "\"r2\"", ",", "(", "isDarwinABI", "||", "isPPC64", ")", "?", "0", ":", "PPC", "::", "R2", ")", ".", "Case", "(", "\"r13\"", ",", "(", "!", "isPPC64", "&&", "isDarwinABI", ")", "?", "0", ":", "(", "is64Bit", "?", "PPC", "::", "X13", ":", "PPC", "::", "R13", ")", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "MVT::i64", "MVT::i32", "PPC", "MVT::i32", "\"Invalid register global variable type\"", "PPC", "MVT::i64", "\"r1\"", "PPC::X1", "PPC::R1", "\"r2\"", "PPC", "0", "PPC::R2", "\"r13\"", "PPC", "0", "PPC::X13", "PPC::R13", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "AMDGPUTargetELFStreamer", "::", "EmitHSAMetadata", "(", "const", "AMDGPU", "::", "HSAMD", "::", "Metadata", "&", "HSAMetadata", ")", "{", "std", "::", "string", "HSAMetadataString", ";", "if", "(", "HSAMD", "::", "toString", "(", "HSAMetadata", ",", "HSAMetadataString", ")", ")", "return", "false", ";", "auto", "&", "Context", "=", "getContext", "(", ")", ";", "auto", "*", "DescBegin", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescEnd", "=", "Context", ".", "createTempSymbol", "(", ")", ";", "auto", "*", "DescSZ", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "DescEnd", ",", "Context", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "DescBegin", ",", "Context", ")", ",", "Context", ")", ";", "EmitNote", "(", "ElfNote", "::", "NoteNameV2", ",", "DescSZ", ",", "ELF", "::", "NT_AMD_AMDGPU_HSA_METADATA", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "emitLabel", "(", "DescBegin", ")", ";", "OS", ".", "emitBytes", "(", "HSAMetadataString", ")", ";", "OS", ".", "emitLabel", "(", "DescEnd", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "HSA", "Metadata", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::HSAMD", "AMDGPU" ]

[]

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

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

[ "X86", "\"X86 Assembly Printer\"" ]

[]

[ "<s>", "Register", "M68kRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "rtx", "riscv_force_binary", "(", "enum", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "riscv_emit_binary", "(", "code", ",", "gen_reg_rtx", "(", "mode", ")", ",", "x", ",", "y", ")", ";", "}", "</s>" ]

[ "Compute", "(", "CODE", "X", "Y", ")", "and", "store", "the", "result", "in", "a", "new", "register", "of", "mode", "MODE", ".", "Return", "that", "new", "register", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "unsigned", "int", "sparc_min_arithmetic_precision", "(", "void", ")", "{", "return", "32", ";", "}", "</s>" ]

[ "Implement", "TARGET_MIN_ARITHMETIC_PRECISION", "." ]

[ "sparc", "32" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOpc", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOpc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Bad branch opcode\"", ")", ";", "case", "MOS", "::", "GBR", ":", "case", "MOS", "::", "BR", ":", "case", "MOS", "::", "BRA", ":", "return", "-", "126", "<=", "BrOffset", "&&", "BrOffset", "<=", "129", ";", "case", "MOS", "::", "JMP", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "MOS", "MOS", "\"Bad branch opcode\"", "MOS::GBR", "MOS::BR", "MOS::BRA", "126", "129", "MOS::JMP" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "rtx", "riscv_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "unsigned", "int", "subcode", "=", "fcode", ">>", "RISCV_BUILTIN_SHIFT", ";", "switch", "(", "fcode", "&", "RISCV_BUILTIN_CLASS", ")", "{", "case", "RISCV_BUILTIN_VECTOR", ":", "return", "riscv_vector", "::", "expand_builtin", "(", "subcode", ",", "exp", ",", "target", ")", ";", "case", "RISCV_BUILTIN_GENERAL", ":", "{", "const", "struct", "riscv_builtin_description", "*", "d", "=", "&", "riscv_builtins", "[", "subcode", "]", ";", "switch", "(", "d", "->", "builtin_type", ")", "{", "case", "RISCV_BUILTIN_DIRECT", ":", "return", "riscv_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "true", ")", ";", "case", "RISCV_BUILTIN_DIRECT_NO_TARGET", ":", "return", "riscv_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "false", ")", ";", "}", "}", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

[ "riscv", "0", "riscv_vector::expand_builtin" ]

[]

[ "<s>", "void", "AVRFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "bool", "isHandler", "=", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "!", "isHandler", ")", "{", "return", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "isHandler", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "AVR", "::", "R0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "OUTARr", ")", ")", ".", "addImm", "(", "0x3f", ")", ".", "addReg", "(", "AVR", "::", "R0", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPWRd", ")", ",", "AVR", "::", "R1R0", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPWRd", ")", ",", "AVR", "::", "R29R28", ")", ";", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "AVR", "::", "POPRd", "&&", "Opc", "!=", "AVR", "::", "POPWRd", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "unsigned", "Opcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "FrameSize", ")", ")", "{", "Opcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "Opcode", "=", "AVR", "::", "SUBIWRdK", ";", "FrameSize", "=", "-", "FrameSize", ";", "}", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "AVR", "::", "R29R28", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "\"Can only insert epilog into returning blocks\"", "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::POPRd", "AVR::R0", "AVR::OUTARr", "0x3f", "AVR::R0", "AVR::POPWRd", "AVR::R1R0", "AVR::POPWRd", "AVR::R29R28", "AVR::POPRd", "AVR::POPWRd", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::R29R28", "AVR::R29R28", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R29R28" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ",", "bool", "MinSize", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "UseMulOps", "(", "UseFusedMulOps", ")", ",", "ReservedGPRegisters", "(", "ARM", "::", "GPRRegClass", ".", "getNumRegs", "(", ")", ")", ",", "CPUString", "(", "CPU", ")", ",", "OptMinSize", "(", "MinSize", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "ARMCallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "ARMLegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "ARMRegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createARMInstructionSelector", "(", "*", "static_cast", "<", "const", "ARMBaseTargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::GPRRegClass", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "const", "uint16_t", "*", "lookup", "(", "unsigned", "opcode", ",", "unsigned", "domain", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "array_lengthof", "(", "ReplaceableInstrs", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "ReplaceableInstrs", "[", "i", "]", "[", "domain", "-", "1", "]", "==", "opcode", ")", "return", "ReplaceableInstrs", "[", "i", "]", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

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

[]

[ "<s>", "CCAssignFn", "*", "ARMFastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "Return", ",", "bool", "isVarArg", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", "&&", "!", "isVarArg", ")", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "return", "(", "Return", "?", "RetFastCC_ARM_APCS", ":", "FastCC_ARM_APCS", ")", ";", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "}", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", "&&", "TM", ".", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Hard", "&&", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "else", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "}", "else", "{", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "}", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "!", "isVarArg", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "case", "CallingConv", "::", "ARM_AAPCS", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "case", "CallingConv", "::", "ARM_APCS", ":", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "case", "CallingConv", "::", "GHC", ":", "if", "(", "Return", ")", "llvm_unreachable", "(", "\"Can't return in GHC call convention\"", ")", ";", "else", "return", "CC_ARM_APCS_GHC", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Unsupported calling convention\"", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "\"Can't return in GHC call convention\"", "ARM" ]

[]

[ "<s>", "int", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FrameOffset", ";", "}", "else", "{", "FrameReg", "=", "SP", "::", "O6", ";", "return", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::O6" ]

[]

[ "<s>", "MCSection", "*", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ")", "const", "override", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "NVPTX" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STriw", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STrid", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STriw_pred", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::STriw", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::STrid", "0", "Hexagon::PredRegsRegClass", "Hexagon::STriw_pred", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "static", "int", "get_element_number", "(", "tree", "vec_type", ",", "tree", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "elt", ",", "max", "=", "TYPE_VECTOR_SUBPARTS", "(", "vec_type", ")", "-", "1", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "(", "elt", "=", "tree_to_uhwi", "(", "arg", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "\"selector must be an integer constant in the range \"", "\"[0, %wi]\"", ",", "max", ")", ";", "return", "0", ";", "}", "return", "elt", ";", "}", "</s>" ]

[ "Return", "the", "integer", "constant", "in", "ARG", ".", "Constrain", "it", "to", "be", "in", "the", "range", "of", "the", "subparts", "of", "VEC_TYPE", ";", "issue", "an", "error", "if", "not", "." ]

[ "i386", "1", "\"selector must be an integer constant in the range \"", "\"[0, %wi]\"", "0" ]

[]

[ "<s>", "void", "scalar_chain", "::", "convert_registers", "(", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs_conv", ",", "0", ",", "id", ",", "bi", ")", "{", "rtx", "chain_reg", "=", "gen_reg_rtx", "(", "smode", ")", ";", "defs_map", ".", "put", "(", "regno_reg_rtx", "[", "id", "]", ",", "chain_reg", ")", ";", "}", "EXECUTE_IF_SET_IN_BITMAP", "(", "insns_conv", ",", "0", ",", "id", ",", "bi", ")", "for", "(", "df_ref", "ref", "=", "DF_INSN_UID_DEFS", "(", "id", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "bitmap_bit_p", "(", "defs_conv", ",", "DF_REF_REGNO", "(", "ref", ")", ")", ")", "make_vector_copies", "(", "DF_REF_INSN", "(", "ref", ")", ",", "DF_REF_REAL_REG", "(", "ref", ")", ")", ";", "}", "</s>" ]

[ "Generate", "copies", "from", "defs", "used", "by", "the", "chain", "but", "not", "defined", "therein", ".", "Also", "populates", "defs_map", "which", "is", "used", "later", "by", "convert_insn", "." ]

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

[]

[ "<s>", "static", "void", "ATTRIBUTE_UNUSED", "ix86_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "ix86_in_large_data_p", "(", "decl", ")", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_FAR_ADDR", ";", "}", "</s>" ]

[ "Implements", "target", "vector", "targetm.asm.encode_section_info", "." ]

[ "i386", "0" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", ")", "{", "if", "(", "Optional", "<", "ConstantRange", ">", "CR", "=", "GV", "->", "getAbsoluteSymbolRange", "(", ")", ")", "{", "if", "(", "CR", "->", "getUnsignedMax", "(", ")", ".", "ult", "(", "128", ")", ")", "return", "X86II", "::", "MO_ABS8", ";", "else", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "}", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "return", "X86II", "::", "MO_COFFSTUB", ";", "}", "if", "(", "isOSWindows", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "isTargetELF", "(", ")", "?", "X86II", "::", "MO_GOT", ":", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "128", "X86II::MO_ABS8", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_COFFSTUB", "X86II::MO_NO_FLAG", "X86II::MO_GOT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "unsigned", "TeakMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Teak", "Teak", "0" ]

[]

[ "<s>", "int", "mips_idiv_insns", "(", "machine_mode", "mode", ")", "{", "int", "count", ";", "count", "=", "1", ";", "if", "(", "TARGET_CHECK_ZERO_DIV", ")", "{", "if", "(", "GENERATE_DIVIDE_TRAPS", "&&", "!", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "count", "++", ";", "else", "count", "+=", "2", ";", "}", "if", "(", "TARGET_FIX_R4000", "||", "TARGET_FIX_R4400", ")", "count", "++", ";", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "for", "an", "integer", "division", "." ]

[ "mips", "1", "2" ]

[]

[ "<s>", "static", "void", "s390_output_indirect_thunk_function", "(", "unsigned", "int", "regno", ",", "bool", "z10_p", ")", "{", "tree", "decl", ";", "char", "thunk_label", "[", "32", "]", ";", "int", "i", ";", "if", "(", "z10_p", ")", "sprintf", "(", "thunk_label", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EXRL", ",", "regno", ")", ";", "else", "sprintf", "(", "thunk_label", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EX", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ",", "regno", ")", ";", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "thunk_label", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "1", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "cgraph_node", "::", "create", "(", "decl", ")", "->", "set_comdat_group", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "targetm", ".", "asm_out", ".", "unique_section", "(", "decl", ",", "0", ")", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "asm_out_file", ",", "thunk_label", ")", ";", "fputs", "(", "\"\\t.hidden\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "thunk_label", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_DECLARE_FUNCTION_NAME", "(", "asm_out_file", ",", "thunk_label", ",", "decl", ")", ";", "}", "else", "{", "switch_to_section", "(", "text_section", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "thunk_label", ")", ";", "}", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "current_function_decl", "=", "decl", ";", "allocate_struct_function", "(", "decl", ",", "false", ")", ";", "init_function_start", "(", "decl", ")", ";", "cfun", "->", "is_thunk", "=", "true", ";", "first_function_block_is_cold", "=", "false", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "asm_out_file", ",", "1", ")", ";", "if", "(", "flag_asynchronous_unwind_tables", "&&", "flag_dwarf2_cfi_asm", ")", "{", "fputs", "(", "\"\\t.cfi_signal_frame\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_return_column %d\\n\"", ",", "regno", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FPR15_REGNUM", ";", "i", "++", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_same_value %s\\n\"", ",", "reg_names", "[", "i", "]", ")", ";", "}", "if", "(", "z10_p", ")", "{", "if", "(", "!", "TARGET_CPU_Z10", ")", "{", "fputs", "(", "\"\\t.machine push\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.machine z10\\n\"", ",", "asm_out_file", ")", ";", "}", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode zarch\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\texrl\\t0,1f\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode esa\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_CPU_Z10", ")", "fputs", "(", "\"\\t.machine pop\\n\"", ",", "asm_out_file", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tlarl\\t%%r%d,1f\\n\"", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tex\\t0,0(%%r%d)\\n\"", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "}", "fputs", "(", "\"0:\\tj\\t0b\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"1:\\tbr\\t%%r%d\\n\"", ",", "regno", ")", ";", "final_end_function", "(", ")", ";", "init_insn_lengths", "(", ")", ";", "free_after_compilation", "(", "cfun", ")", ";", "set_cfun", "(", "NULL", ")", ";", "current_function_decl", "=", "NULL", ";", "}", "</s>" ]

[ "Output", "an", "indirect", "branch", "trampoline", "for", "target", "register", "REGNO", "." ]

[ "s390", "32", "1", "1", "1", "0", "0", "\"\\t.hidden\\t\"", "1", "\"\\t.cfi_signal_frame\\n\"", "\"\\t.cfi_return_column %d\\n\"", "0", "\"\\t.cfi_same_value %s\\n\"", "\"\\t.machine push\\n\"", "\"\\t.machine z10\\n\"", "\"\\t.machinemode zarch\\n\"", "\"\\texrl\\t0,1f\\n\"", "\"\\t.machinemode esa\\n\"", "\"\\t.machine pop\\n\"", "\"\\tlarl\\t%%r%d,1f\\n\"", "\"\\tex\\t0,0(%%r%d)\\n\"", "\"0:\\tj\\t0b\\n\"", "\"1:\\tbr\\t%%r%d\\n\"" ]

[]

[ "<s>", "bool", "sh_is_logical_t_store_expr", "(", "rtx", "op", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "logical_operator", "(", "op", ",", "SImode", ")", ")", "return", "false", ";", "rtx", "ops", "[", "2", "]", "=", "{", "XEXP", "(", "op", ",", "0", ")", ",", "XEXP", "(", "op", ",", "1", ")", "}", ";", "int", "op_is_t_count", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "++", "i", ")", "{", "if", "(", "t_reg_operand", "(", "ops", "[", "i", "]", ",", "VOIDmode", ")", "||", "negt_reg_operand", "(", "ops", "[", "i", "]", ",", "VOIDmode", ")", ")", "op_is_t_count", "++", ";", "else", "{", "set_of_reg", "op_set", "=", "sh_find_set_of_reg", "(", "ops", "[", "i", "]", ",", "insn", ",", "prev_nonnote_nondebug_insn_bb", ")", ";", "if", "(", "op_set", ".", "set_src", "==", "NULL_RTX", ")", "continue", ";", "if", "(", "t_reg_operand", "(", "op_set", ".", "set_src", ",", "VOIDmode", ")", "||", "negt_reg_operand", "(", "op_set", ".", "set_src", ",", "VOIDmode", ")", "||", "sh_is_logical_t_store_expr", "(", "op_set", ".", "set_src", ",", "op_set", ".", "insn", ")", ")", "op_is_t_count", "++", ";", "}", "}", "return", "op_is_t_count", "==", "2", ";", "}", "</s>" ]

[ "Given", "an", "op", "rtx", "and", "an", "insn", ",", "try", "to", "find", "out", "whether", "the", "result", "of", "the", "specified", "op", "consists", "only", "of", "logical", "operations", "on", "T", "bit", "stores", "." ]

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

[]

[ "<s>", "static", "bool", "important_for_bundling_p", "(", "rtx_insn", "*", "insn", ")", "{", "return", "(", "INSN_P", "(", "insn", ")", "&&", "ia64_safe_itanium_class", "(", "insn", ")", "!=", "ITANIUM_CLASS_IGNORE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", ";", "}", "</s>" ]

[ "True", "when", "INSN", "is", "important", "for", "bundling", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "ix86_memmodel_check", "(", "unsigned", "HOST_WIDE_INT", "val", ")", "{", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "val", ")", ";", "bool", "strong", ";", "if", "(", "val", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "IX86_HLE_ACQUIRE", "|", "IX86_HLE_RELEASE", "|", "MEMMODEL_MASK", ")", "||", "(", "(", "val", "&", "IX86_HLE_ACQUIRE", ")", "&&", "(", "val", "&", "IX86_HLE_RELEASE", ")", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"unknown architecture specific memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", ";", "}", "strong", "=", "(", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", ";", "if", "(", "val", "&", "IX86_HLE_ACQUIRE", "&&", "!", "(", "is_mm_acquire", "(", "model", ")", "||", "strong", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"HLE_ACQUIRE not used with ACQUIRE or stronger memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", "|", "IX86_HLE_ACQUIRE", ";", "}", "if", "(", "val", "&", "IX86_HLE_RELEASE", "&&", "!", "(", "is_mm_release", "(", "model", ")", "||", "strong", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"HLE_RELEASE not used with RELEASE or stronger memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", "|", "IX86_HLE_RELEASE", ";", "}", "return", "val", ";", "}", "</s>" ]

[ "Validate", "target", "specific", "memory", "model", "bits", "in", "VAL", "." ]

[ "i386", "\"unknown architecture specific memory model\"", "\"HLE_ACQUIRE not used with ACQUIRE or stronger memory model\"", "\"HLE_RELEASE not used with RELEASE or stronger memory model\"" ]

[]

[ "<s>", "bool", "SPUTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createSPUISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Memory Intrinsic Results\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Memory Intrinsic Results\"" ]

[]

[ "<s>", "static", "int", "loongarch_set_reg_reg_cost", "(", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_CC", ":", "return", "loongarch_set_reg_reg_piece_cost", "(", "mode", ",", "GET_MODE_SIZE", "(", "CCmode", ")", ")", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "case", "MODE_VECTOR_FLOAT", ":", "if", "(", "TARGET_HARD_FLOAT", ")", "return", "loongarch_set_reg_reg_piece_cost", "(", "mode", ",", "UNITS_PER_HWFPVALUE", ")", ";", "default", ":", "return", "loongarch_set_reg_reg_piece_cost", "(", "mode", ",", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "between", "two", "registers", "of", "mode", "MODE", "." ]

[ "loongarch" ]

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "Gen", "=", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", "?", "SIEncodingFamily", "::", "SDWA9", ":", "SIEncodingFamily", "::", "SDWA", ";", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "SIEncodingFamily::SDWA", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "rtx", "extract_branch_target_rtx", "(", "rtx_insn", "*", "insn", ")", "{", "gcc_assert", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", ")", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "IF_THEN_ELSE", ")", "return", "NULL_RTX", ";", "return", "SET_SRC", "(", "body", ")", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "==", "CALL", ")", "return", "XEXP", "(", "body", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "PARALLEL", ")", "{", "rtx", "first_rtx", "=", "parallel_element", "(", "body", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "first_rtx", ")", "==", "SET", ")", "return", "SET_SRC", "(", "first_rtx", ")", ";", "if", "(", "GET_CODE", "(", "first_rtx", ")", "==", "CALL", ")", "return", "XEXP", "(", "first_rtx", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "==", "COND_EXEC", ")", "{", "rtx", "addr_rtx", "=", "XEXP", "(", "body", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "SET", ")", "return", "SET_SRC", "(", "addr_rtx", ")", ";", "if", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "PARALLEL", ")", "{", "rtx", "first_rtx", "=", "parallel_element", "(", "addr_rtx", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "first_rtx", ")", "==", "SET", ")", "{", "rtx", "call_rtx", "=", "SET_SRC", "(", "first_rtx", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "call_rtx", ")", "==", "CALL", ")", ";", "return", "XEXP", "(", "call_rtx", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "first_rtx", ")", "==", "CALL", ")", "return", "XEXP", "(", "first_rtx", ",", "0", ")", ";", "}", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Extract", "the", "rtx", "representing", "the", "branch", "target", "to", "help", "recognize", "data", "hazards", "." ]

[ "nds32", "0", "0", "0", "1", "0", "0", "0" ]

[]