Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "section", "*", "riscv_elf_select_rtx_section", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "s", "=", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "if", "(", "riscv_size_ok_for_small_data_p", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", "{", "if", "(", "strncmp", "(", "s", "->", "named", ".", "name", ",", "\".rodata.cst\"", ",", "strlen", "(", "\".rodata.cst\"", ")", ")", "==", "0", ")", "{", "char", "*", "name", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "s", "->", "named", ".", "name", ")", "+", "2", ")", ";", "sprintf", "(", "name", ",", "\".s%s\"", ",", "s", "->", "named", ".", "name", "+", "1", ")", ";", "return", "get_section", "(", "name", ",", "s", "->", "named", ".", "common", ".", "flags", ",", "NULL", ")", ";", "}", "if", "(", "s", "==", "data_section", ")", "return", "sdata_section", ";", "}", "return", "s", ";", "}", "</s>" ]

[ "Return", "a", "section", "for", "X", ",", "handling", "small", "data", "." ]

[ "riscv", "\".rodata.cst\"", "\".rodata.cst\"", "0", "2", "\".s%s\"", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MipsSETargetLowering", "::", "getRepRegClassFor", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "Untyped", ")", "return", "Subtarget", ".", "hasDSP", "(", ")", "?", "&", "Mips", "::", "ACC64DSPRegClass", ":", "&", "Mips", "::", "ACC64RegClass", ";", "return", "TargetLowering", "::", "getRepRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "Mips", "Mips", "MVT::Untyped", "Mips::ACC64DSPRegClass", "Mips::ACC64RegClass" ]

[]

[ "<s>", "const", "MipsTargetLowering", "*", "MipsTargetLowering", "::", "create", "(", "MipsTargetMachine", "&", "TM", ",", "const", "MipsSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "llvm", "::", "createMips16TargetLowering", "(", "TM", ",", "STI", ")", ";", "return", "llvm", "::", "createMipsSETargetLowering", "(", "TM", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "avr_notice_update_cc", "(", "rtx", "body", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", ";", "enum", "attr_cc", "cc", "=", "get_attr_cc", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "break", ";", "case", "CC_PLUS", ":", "case", "CC_LDI", ":", "{", "rtx", "*", "op", "=", "recog_data", ".", "operand", ";", "int", "len_dummy", ",", "icc", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CC_PLUS", ":", "avr_out_plus", "(", "insn", ",", "op", ",", "&", "len_dummy", ",", "&", "icc", ")", ";", "cc", "=", "(", "enum", "attr_cc", ")", "icc", ";", "break", ";", "case", "CC_LDI", ":", "cc", "=", "(", "op", "[", "1", "]", "==", "CONST0_RTX", "(", "GET_MODE", "(", "op", "[", "0", "]", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "zero_reg_rtx", ")", ")", "?", "CC_CLOBBER", ":", "CC_NONE", ";", "break", ";", "}", "break", ";", "}", "}", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "CC_NONE", ":", "break", ";", "case", "CC_SET_N", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_ZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_SET_VZN", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_CZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "}", "}", "</s>" ]

[ "Update", "the", "condition", "code", "in", "the", "INSN", "." ]

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

[]

[ "<s>", "int", "cr16_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "cr16_compute_save_regs", "(", ")", ";", "cr16_compute_frame", "(", ")", ";", "if", "(", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", ")", "return", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "else", "if", "(", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "FRAME_POINTER_REGNUM", ")", ")", "return", "(", "current_frame_info", ".", "reg_size", "+", "current_frame_info", ".", "var_size", ")", ";", "else", "if", "(", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", ")", "return", "(", "current_frame_info", ".", "reg_size", "+", "current_frame_info", ".", "var_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "INITIAL_ELIMINATION_OFFSET", ",", "return", "the", "OFFSET", "." ]

[ "cr16", "0", "0" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "if", "(", "NoFusing", ")", "return", "NULL", ";", "unsigned", "Alignment", "=", "0", ";", "if", "(", "LoadMI", "->", "hasOneMemOperand", "(", ")", ")", "Alignment", "=", "LoadMI", "->", "memoperands_begin", "(", ")", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", "<", "16", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "FsANDNPDrr", ":", "case", "X86", "::", "FsANDNPSrr", ":", "case", "X86", "::", "FsANDPDrr", ":", "case", "X86", "::", "FsANDPSrr", ":", "case", "X86", "::", "FsORPDrr", ":", "case", "X86", "::", "FsORPSrr", ":", "case", "X86", "::", "FsXORPDrr", ":", "case", "X86", "::", "FsXORPSrr", ":", "return", "NULL", ";", "}", "}", "if", "(", "Ops", ".", "size", "(", ")", "==", "2", "&&", "Ops", "[", "0", "]", "==", "0", "&&", "Ops", "[", "1", "]", "==", "1", ")", "{", "unsigned", "NewOpc", "=", "0", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "NULL", ";", "case", "X86", "::", "TEST8rr", ":", "NewOpc", "=", "X86", "::", "CMP8ri", ";", "break", ";", "case", "X86", "::", "TEST16rr", ":", "NewOpc", "=", "X86", "::", "CMP16ri", ";", "break", ";", "case", "X86", "::", "TEST32rr", ":", "NewOpc", "=", "X86", "::", "CMP32ri", ";", "break", ";", "case", "X86", "::", "TEST64rr", ":", "NewOpc", "=", "X86", "::", "CMP64ri32", ";", "break", ";", "}", "MI", "->", "setDesc", "(", "get", "(", "NewOpc", ")", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "}", "else", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "MOs", ";", "if", "(", "LoadMI", "->", "getOpcode", "(", ")", "==", "X86", "::", "V_SET0", "||", "LoadMI", "->", "getOpcode", "(", ")", "==", "X86", "::", "V_SETALLONES", ")", "{", "unsigned", "PICBase", "=", "0", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", "&&", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "MachineConstantPool", "&", "MCP", "=", "*", "MF", ".", "getConstantPool", "(", ")", ";", "const", "VectorType", "*", "Ty", "=", "VectorType", "::", "get", "(", "Type", "::", "Int32Ty", ",", "4", ")", ";", "Constant", "*", "C", "=", "LoadMI", "->", "getOpcode", "(", ")", "==", "X86", "::", "V_SET0", "?", "ConstantVector", "::", "getNullValue", "(", "Ty", ")", ":", "ConstantVector", "::", "getAllOnesValue", "(", "Ty", ")", ";", "unsigned", "CPI", "=", "MCP", ".", "getConstantPoolIndex", "(", "C", ",", "16", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "PICBase", ",", "false", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "1", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "0", ",", "false", ")", ")", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateCPI", "(", "CPI", ",", "0", ")", ")", ";", "}", "else", "{", "unsigned", "NumOps", "=", "LoadMI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "i", "=", "NumOps", "-", "4", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "MOs", ".", "push_back", "(", "LoadMI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "return", "foldMemoryOperandImpl", "(", "MF", ",", "MI", ",", "Ops", "[", "0", "]", ",", "MOs", ")", ";", "}", "</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", "0", "16", "X86::FsANDNPDrr", "X86::FsANDNPSrr", "X86::FsANDPDrr", "X86::FsANDPSrr", "X86::FsORPDrr", "X86::FsORPSrr", "X86::FsXORPDrr", "X86::FsXORPSrr", "2", "0", "0", "1", "1", "0", "X86::TEST8rr", "X86::CMP8ri", "X86::TEST16rr", "X86::CMP16ri", "X86::TEST32rr", "X86::CMP32ri", "X86::TEST64rr", "X86::CMP64ri32", "1", "0", "1", "4", "X86::V_SET0", "X86::V_SETALLONES", "0", "X86", "4", "X86::V_SET0", "16", "1", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "save_entry", "*", "sh5_schedule_saves", "(", "HARD_REG_SET", "*", "live_regs_mask", ",", "save_schedule", "*", "schedule", ",", "int", "offset_base", ")", "{", "int", "align", ",", "i", ";", "save_entry", "*", "entry", "=", "schedule", "->", "entries", ";", "int", "tmpx", "=", "0", ";", "int", "offset", ";", "if", "(", "!", "current_function_interrupt", ")", "for", "(", "i", "=", "FIRST_GENERAL_REG", ";", "tmpx", "<", "MAX_TEMPS", "&&", "i", "<=", "LAST_GENERAL_REG", ";", "i", "++", ")", "if", "(", "call_really_used_regs", "[", "i", "]", "&&", "!", "fixed_regs", "[", "i", "]", "&&", "i", "!=", "PR_MEDIA_REG", "&&", "!", "FUNCTION_ARG_REGNO_P", "(", "i", ")", "&&", "i", "!=", "FIRST_RET_REG", "&&", "!", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", "&&", "i", "==", "STATIC_CHAIN_REGNUM", ")", "&&", "!", "(", "crtl", "->", "calls_eh_return", "&&", "(", "i", "==", "EH_RETURN_STACKADJ_REGNO", "||", "(", "(", "unsigned", ")", "i", ">=", "EH_RETURN_DATA_REGNO", "(", "0", ")", "&&", "(", "unsigned", ")", "i", "<=", "EH_RETURN_DATA_REGNO", "(", "3", ")", ")", ")", ")", ")", "schedule", "->", "temps", "[", "tmpx", "++", "]", "=", "i", ";", "entry", "->", "reg", "=", "-", "1", ";", "entry", "->", "mode", "=", "VOIDmode", ";", "entry", "->", "offset", "=", "offset_base", ";", "entry", "++", ";", "offset", "=", "offset_base", ";", "for", "(", "align", "=", "1", ";", "align", ">=", "0", ";", "align", "--", ")", "{", "for", "(", "i", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "i", ")", ")", "{", "machine_mode", "mode", "=", "REGISTER_NATURAL_MODE", "(", "i", ")", ";", "int", "reg", "=", "i", ";", "if", "(", "current_function_interrupt", ")", "{", "if", "(", "TARGET_REGISTER_P", "(", "i", ")", ")", "continue", ";", "if", "(", "GENERAL_REGISTER_P", "(", "i", ")", ")", "mode", "=", "DImode", ";", "}", "if", "(", "mode", "==", "SFmode", "&&", "(", "i", "%", "2", ")", "==", "1", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_REGISTER_P", "(", "i", ")", "&&", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "(", "i", "^", "1", ")", ")", ")", ")", "{", "mode", "=", "DFmode", ";", "i", "--", ";", "reg", "--", ";", "}", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "==", "0", ")", "!=", "align", ")", "continue", ";", "if", "(", "current_function_interrupt", "&&", "GENERAL_REGISTER_P", "(", "i", ")", "&&", "tmpx", "<", "MAX_TEMPS", ")", "schedule", "->", "temps", "[", "tmpx", "++", "]", "=", "i", ";", "offset", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "entry", "->", "reg", "=", "i", ";", "entry", "->", "mode", "=", "mode", ";", "entry", "->", "offset", "=", "offset", ";", "entry", "++", ";", "}", "if", "(", "align", "&&", "current_function_interrupt", ")", "for", "(", "i", "=", "LAST_TARGET_REG", ";", "i", ">=", "FIRST_TARGET_REG", ";", "i", "--", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "i", ")", ")", "{", "offset", "-=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "entry", "->", "reg", "=", "i", ";", "entry", "->", "mode", "=", "DImode", ";", "entry", "->", "offset", "=", "offset", ";", "entry", "++", ";", "}", "}", "entry", "->", "reg", "=", "-", "1", ";", "entry", "->", "mode", "=", "VOIDmode", ";", "entry", "->", "offset", "=", "offset", ";", "schedule", "->", "temps", "[", "tmpx", "]", "=", "-", "1", ";", "return", "entry", "-", "1", ";", "}", "</s>" ]

[ "Fill", "in", "SCHEDULE", "according", "to", "LIVE_REGS_MASK", ".", "If", "RESTORE", "is", "nonzero", ",", "use", "reverse", "order", ".", "Returns", "the", "last", "entry", "written", "to", "(", "not", "counting", "the", "delimiter", ")", ".", "OFFSET_BASE", "is", "a", "number", "to", "be", "added", "to", "all", "offset", "entries", "." ]

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

[]

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

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

[ "stormy16", "1" ]

[]

[ "<s>", "static", "unsigned", "convertToFlagSettingOpc", "(", "unsigned", "Opc", ",", "bool", "&", "Is64Bit", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has no flag setting equivalent!\"", ")", ";", "case", "AArch64", "::", "ADDWri", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ADDSWri", ";", "case", "AArch64", "::", "ADDWrr", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ADDSWrr", ";", "case", "AArch64", "::", "ADDWrs", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ADDSWrs", ";", "case", "AArch64", "::", "ADDWrx", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ADDSWrx", ";", "case", "AArch64", "::", "ANDWri", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ANDSWri", ";", "case", "AArch64", "::", "ANDWrr", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ANDSWrr", ";", "case", "AArch64", "::", "ANDWrs", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "ANDSWrs", ";", "case", "AArch64", "::", "BICWrr", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "BICSWrr", ";", "case", "AArch64", "::", "BICWrs", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "BICSWrs", ";", "case", "AArch64", "::", "SUBWri", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "SUBSWri", ";", "case", "AArch64", "::", "SUBWrr", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "SUBSWrr", ";", "case", "AArch64", "::", "SUBWrs", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "SUBSWrs", ";", "case", "AArch64", "::", "SUBWrx", ":", "Is64Bit", "=", "false", ";", "return", "AArch64", "::", "SUBSWrx", ";", "case", "AArch64", "::", "ADDXri", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ADDSXri", ";", "case", "AArch64", "::", "ADDXrr", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ADDSXrr", ";", "case", "AArch64", "::", "ADDXrs", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ADDSXrs", ";", "case", "AArch64", "::", "ADDXrx", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ADDSXrx", ";", "case", "AArch64", "::", "ANDXri", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ANDSXri", ";", "case", "AArch64", "::", "ANDXrr", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ANDSXrr", ";", "case", "AArch64", "::", "ANDXrs", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "ANDSXrs", ";", "case", "AArch64", "::", "BICXrr", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "BICSXrr", ";", "case", "AArch64", "::", "BICXrs", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "BICSXrs", ";", "case", "AArch64", "::", "SUBXri", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "SUBSXri", ";", "case", "AArch64", "::", "SUBXrr", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "SUBSXrr", ";", "case", "AArch64", "::", "SUBXrs", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "SUBSXrs", ";", "case", "AArch64", "::", "SUBXrx", ":", "Is64Bit", "=", "true", ";", "return", "AArch64", "::", "SUBSXrx", ";", "}", "}", "</s>" ]

[ "Return", "the", "opcode", "that", "set", "flags", "when", "possible", "." ]

[ "AArch64", "\"Opcode has no flag setting equivalent!\"", "AArch64::ADDWri", "AArch64::ADDSWri", "AArch64::ADDWrr", "AArch64::ADDSWrr", "AArch64::ADDWrs", "AArch64::ADDSWrs", "AArch64::ADDWrx", "AArch64::ADDSWrx", "AArch64::ANDWri", "AArch64::ANDSWri", "AArch64::ANDWrr", "AArch64::ANDSWrr", "AArch64::ANDWrs", "AArch64::ANDSWrs", "AArch64::BICWrr", "AArch64::BICSWrr", "AArch64::BICWrs", "AArch64::BICSWrs", "AArch64::SUBWri", "AArch64::SUBSWri", "AArch64::SUBWrr", "AArch64::SUBSWrr", "AArch64::SUBWrs", "AArch64::SUBSWrs", "AArch64::SUBWrx", "AArch64::SUBSWrx", "AArch64::ADDXri", "AArch64::ADDSXri", "AArch64::ADDXrr", "AArch64::ADDSXrr", "AArch64::ADDXrs", "AArch64::ADDSXrs", "AArch64::ADDXrx", "AArch64::ADDSXrx", "AArch64::ANDXri", "AArch64::ANDSXri", "AArch64::ANDXrr", "AArch64::ANDSXrr", "AArch64::ANDXrs", "AArch64::ANDSXrs", "AArch64::BICXrr", "AArch64::BICSXrr", "AArch64::BICXrs", "AArch64::BICSXrs", "AArch64::SUBXri", "AArch64::SUBSXri", "AArch64::SUBXrr", "AArch64::SUBSXrr", "AArch64::SUBXrs", "AArch64::SUBSXrs", "AArch64::SUBXrx", "AArch64::SUBSXrx" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "return", "createR600MachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "R600" ]

[]

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

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

[ "TMS320C64X" ]

[]

[ "<s>", "void", "machopic_output_stub", "(", "FILE", "*", "file", ",", "const", "char", "*", "symb", ",", "const", "char", "*", "stub", ")", "{", "unsigned", "int", "length", ";", "char", "*", "binder_name", ",", "*", "symbol_name", ",", "lazy_ptr_name", "[", "32", "]", ";", "int", "label", "=", "++", "current_machopic_label_num", ";", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "symb", "=", "targetm", ".", "strip_name_encoding", "(", "symb", ")", ";", "length", "=", "strlen", "(", "stub", ")", ";", "binder_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_BINDER_NAME_FOR_STUB", "(", "binder_name", ",", "stub", ",", "length", ")", ";", "length", "=", "strlen", "(", "symb", ")", ";", "symbol_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_SYMBOL_NAME_FOR_SYMBOL", "(", "symbol_name", ",", "symb", ",", "length", ")", ";", "sprintf", "(", "lazy_ptr_name", ",", "\"L%d$lz\"", ",", "label", ")", ";", "if", "(", "MACHOPIC_ATT_STUB", ")", "switch_to_section", "(", "darwin_sections", "[", "machopic_picsymbol_stub3_section", "]", ")", ";", "else", "if", "(", "MACHOPIC_PURE", ")", "switch_to_section", "(", "darwin_sections", "[", "machopic_picsymbol_stub2_section", "]", ")", ";", "else", "switch_to_section", "(", "darwin_sections", "[", "machopic_symbol_stub_section", "]", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "if", "(", "MACHOPIC_ATT_STUB", ")", "{", "fprintf", "(", "file", ",", "\"\\thlt ; hlt ; hlt ; hlt ; hlt\\n\"", ")", ";", "}", "else", "if", "(", "MACHOPIC_PURE", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "2", ")", ";", "output_set_got", "(", "tmp", ",", "NULL_RTX", ")", ";", "fprintf", "(", "file", ",", "\"LPC$%d:\\tmovl\\t%s-LPC$%d(%%ecx),%%ecx\\n\"", ",", "label", ",", "lazy_ptr_name", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tjmp\\t*%%ecx\\n\"", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\tjmp\\t*%s\\n\"", ",", "lazy_ptr_name", ")", ";", "if", "(", "MACHOPIC_ATT_STUB", ")", "return", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "binder_name", ")", ";", "if", "(", "MACHOPIC_PURE", ")", "{", "fprintf", "(", "file", ",", "\"\\tlea\\t%s-%s(%%ecx),%%ecx\\n\"", ",", "lazy_ptr_name", ",", "binder_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tpushl\\t%%ecx\\n\"", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\tpushl\\t$%s\\n\"", ",", "lazy_ptr_name", ")", ";", "fputs", "(", "\"\\tjmp\\tdyld_stub_binding_helper\\n\"", ",", "file", ")", ";", "if", "(", "MACHOPIC_PURE", ")", "{", "switch_to_section", "(", "darwin_sections", "[", "machopic_lazy_symbol_ptr2_section", "]", ")", ";", "}", "else", "switch_to_section", "(", "darwin_sections", "[", "machopic_lazy_symbol_ptr3_section", "]", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "ASM_LONG", "\"%s\\n\"", ",", "binder_name", ")", ";", "}", "</s>" ]

[ "Generate", "external", "symbol", "indirection", "stubs", "(", "PIC", "and", "non-PIC", ")", "." ]

[ "i386", "32", "32", "32", "\"L%d$lz\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\thlt ; hlt ; hlt ; hlt ; hlt\\n\"", "2", "\"LPC$%d:\\tmovl\\t%s-LPC$%d(%%ecx),%%ecx\\n\"", "\"\\tjmp\\t*%%ecx\\n\"", "\"\\tjmp\\t*%s\\n\"", "\"%s:\\n\"", "\"\\tlea\\t%s-%s(%%ecx),%%ecx\\n\"", "\"\\tpushl\\t%%ecx\\n\"", "\"\\tpushl\\t$%s\\n\"", "\"\\tjmp\\tdyld_stub_binding_helper\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"%s\\n\"" ]

[]

[ "<s>", "static", "void", "cr16_override_options", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "flag_exceptions", ")", "flag_cse_follow_jumps", "=", "0", ";", "if", "(", "flag_pic", "==", "NEAR_PIC", ")", "{", "data_model", "=", "DM_FAR", ";", "}", "if", "(", "cr16_data_model", ")", "{", "if", "(", "strcmp", "(", "cr16_data_model", ",", "\"medium\"", ")", "==", "0", ")", "data_model", "=", "DM_DEFAULT", ";", "else", "if", "(", "strcmp", "(", "cr16_data_model", ",", "\"near\"", ")", "==", "0", ")", "data_model", "=", "DM_NEAR", ";", "else", "if", "(", "strcmp", "(", "cr16_data_model", ",", "\"far\"", ")", "==", "0", ")", "{", "if", "(", "TARGET_CR16CP", ")", "data_model", "=", "DM_FAR", ";", "else", "error", "(", "\"data-model=far not valid for cr16c architecture\"", ")", ";", "}", "else", "error", "(", "\"invalid data model option %<-mdata-model=%s%>\"", ",", "cr16_data_model", ")", ";", "}", "else", "data_model", "=", "DM_DEFAULT", ";", "}", "</s>" ]

[ "Parse", "relevant", "options", "and", "override", "." ]

[ "cr16", "0", "0", "\"medium\"", "0", "\"near\"", "0", "\"far\"", "0", "\"data-model=far not valid for cr16c architecture\"", "\"invalid data model option %<-mdata-model=%s%>\"" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "for", "(", "MCSubRegIterator", "SI", "(", "*", "I", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "static", "void", "parse_mtune_ctrl_str", "(", "struct", "gcc_options", "*", "opts", ",", "bool", "dump", ")", "{", "if", "(", "!", "opts", "->", "x_ix86_tune_ctrl_string", ")", "return", ";", "char", "*", "next_feature_string", "=", "NULL", ";", "char", "*", "curr_feature_string", "=", "xstrdup", "(", "opts", "->", "x_ix86_tune_ctrl_string", ")", ";", "char", "*", "orig", "=", "curr_feature_string", ";", "int", "i", ";", "do", "{", "bool", "clear", "=", "false", ";", "next_feature_string", "=", "strchr", "(", "curr_feature_string", ",", "','", ")", ";", "if", "(", "next_feature_string", ")", "*", "next_feature_string", "++", "=", "'\\0'", ";", "if", "(", "*", "curr_feature_string", "==", "'^'", ")", "{", "curr_feature_string", "++", ";", "clear", "=", "true", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "i", "++", ")", "{", "if", "(", "!", "strcmp", "(", "curr_feature_string", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ")", "{", "ix86_tune_features", "[", "i", "]", "=", "!", "clear", ";", "if", "(", "dump", ")", "fprintf", "(", "stderr", ",", "\"Explicitly %s feature %s\\n\"", ",", "clear", "?", "\"clear\"", ":", "\"set\"", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ";", "break", ";", "}", "}", "if", "(", "i", "==", "X86_TUNE_LAST", ")", "error", "(", "\"unknown parameter to option %<-mtune-ctrl%>: %s\"", ",", "clear", "?", "curr_feature_string", "-", "1", ":", "curr_feature_string", ")", ";", "curr_feature_string", "=", "next_feature_string", ";", "}", "while", "(", "curr_feature_string", ")", ";", "free", "(", "orig", ")", ";", "}", "</s>" ]

[ "parse", "-mtune-ctrl=", "option", ".", "When", "DUMP", "is", "true", ",", "print", "the", "features", "that", "are", "explicitly", "set", "." ]

[ "i386", "0", "\"Explicitly %s feature %s\\n\"", "\"clear\"", "\"set\"", "\"unknown parameter to option %<-mtune-ctrl%>: %s\"", "1" ]

[]

[ "<s>", "Register", "XCoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "XCore", "::", "R10", ":", "XCore", "::", "SP", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore::R10", "XCore::SP" ]

[]

[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "UseSoftMulDiv", "=", "false", ";", "IsV9", "=", "false", ";", "IsLeon", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "IsVIS2", "=", "false", ";", "IsVIS3", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasNoFSMULD", "=", "false", ";", "HasNoFMULS", "=", "false", ";", "HasLeonCasa", "=", "false", ";", "HasUmacSmac", "=", "false", ";", "PerformSDIVReplace", "=", "false", ";", "InsertNOPLoad", "=", "false", ";", "FixAllFDIVSQRT", "=", "false", ";", "DetectRoundChange", "=", "false", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]

[]

[ "<s>", "int", "avr_simple_epilogue", "(", "void", ")", "{", "return", "(", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "avr_regs_to_save", "(", "NULL", ")", "==", "0", "&&", "!", "interrupt_function_p", "(", "current_function_decl", ")", "&&", "!", "signal_function_p", "(", "current_function_decl", ")", "&&", "!", "avr_naked_function_p", "(", "current_function_decl", ")", "&&", "!", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "!", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "function", "epilogue", "is", "just", "a", "single", "``", "ret", "''", "." ]

[ "avr", "0", "0" ]

[]

[ "<s>", "void", "handle_arm_sve_h", "(", ")", "{", "if", "(", "function_table", ")", "{", "error", "(", "\"duplicate definition of %qs\"", ",", "\"arm_sve.h\"", ")", ";", "return", ";", "}", "sve_switcher", "sve", ";", "for", "(", "unsigned", "int", "type_i", "=", "0", ";", "type_i", "<", "NUM_VECTOR_TYPES", ";", "++", "type_i", ")", "{", "vector_type_index", "type", "=", "vector_type_index", "(", "type_i", ")", ";", "register_vector_type", "(", "type", ")", ";", "if", "(", "type", "!=", "VECTOR_TYPE_svbool_t", ")", "for", "(", "unsigned", "int", "count", "=", "2", ";", "count", "<=", "MAX_TUPLE_SIZE", ";", "++", "count", ")", "register_tuple_type", "(", "count", ",", "type", ")", ";", "}", "register_svpattern", "(", ")", ";", "register_svprfop", "(", ")", ";", "function_table", "=", "new", "hash_table", "<", "registered_function_hasher", ">", "(", "1023", ")", ";", "function_builder", "builder", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "function_groups", ")", ";", "++", "i", ")", "builder", ".", "register_function_group", "(", "function_groups", "[", "i", "]", ")", ";", "}", "</s>" ]

[ "Implement", "#", "pragma", "GCC", "aarch64", "``", "arm_sve.h", "''", "." ]

[ "aarch64", "\"duplicate definition of %qs\"", "\"arm_sve.h\"", "0", "2", "1023", "0" ]

[]

[ "<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", "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", ")", ";", "}", "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", "ISD::AND", "ISD::OR", "ISD::ADD" ]

[]

[ "<s>", "void", "VERegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "VEFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "\"Unexpected\"", "VE", "1" ]

[]

[ "<s>", "bool", "RedundantInstrElimination", "::", "processBlock", "(", "MachineBasicBlock", "&", "B", ",", "const", "RegisterSet", "&", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ",", "NextI", "=", "I", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "*", "MI", "=", "&", "*", "I", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "COPY", ")", "continue", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "isInlineAsm", "(", ")", ")", "continue", ";", "unsigned", "NumD", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ";", "if", "(", "NumD", "!=", "1", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RD", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "!", "BT", ".", "has", "(", "RD", ".", "Reg", ")", ")", "continue", ";", "const", "BitTracker", "::", "RegisterCell", "&", "DC", "=", "BT", ".", "lookup", "(", "RD", ".", "Reg", ")", ";", "auto", "At", "=", "MI", "->", "isPHI", "(", ")", "?", "B", ".", "getFirstNonPHI", "(", ")", ":", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "uses", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RS", "=", "Op", ";", "if", "(", "!", "BT", ".", "has", "(", "RS", ".", "Reg", ")", ")", "continue", ";", "if", "(", "!", "HBS", "::", "isTransparentCopy", "(", "RD", ",", "RS", ",", "MRI", ")", ")", "continue", ";", "unsigned", "BN", ",", "BW", ";", "if", "(", "!", "HBS", "::", "getSubregMask", "(", "RS", ",", "BN", ",", "BW", ",", "MRI", ")", ")", "continue", ";", "const", "BitTracker", "::", "RegisterCell", "&", "SC", "=", "BT", ".", "lookup", "(", "RS", ".", "Reg", ")", ";", "if", "(", "!", "usedBitsEqual", "(", "RD", ",", "RS", ")", "&&", "!", "HBS", "::", "isEqual", "(", "DC", ",", "0", ",", "SC", ",", "BN", ",", "BW", ")", ")", "continue", ";", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "FRC", "=", "HBS", "::", "getFinalVRegClass", "(", "RD", ",", "MRI", ")", ";", "unsigned", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "FRC", ")", ";", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewR", ")", ".", "addReg", "(", "RS", ".", "Reg", ",", "0", ",", "RS", ".", "Sub", ")", ";", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "RD", ".", "Sub", ",", "NewR", ",", "0", ",", "MRI", ")", ";", "BT", ".", "put", "(", "BitTracker", "::", "RegisterRef", "(", "NewR", ")", ",", "SC", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

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

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AS", "==", "AMDGPUASI", ".", "GLOBAL_ADDRESS", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "AS", "==", "AMDGPUASI", ".", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "CONSTANT_ADDRESS_32BIT", ")", "{", "if", "(", "AM", ".", "BaseOffs", "%", "4", "!=", "0", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Ty", "->", "isSized", "(", ")", "&&", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "4", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "SISubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "32", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "SISubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "\"unhandled generation\"", ")", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "PRIVATE_ADDRESS", ")", "{", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "REGION_ADDRESS", ")", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUASI", ".", "FLAT_ADDRESS", "||", "AS", "==", "AMDGPUASI", ".", "UNKNOWN_ADDRESS_SPACE", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "4", "0", "4", "SI", "8", "4", "SI", "32", "4", "SI", "20", "\"unhandled generation\"", "0", "1", "SI", "SI", "SI", "16", "0", "1", "SI", "SI", "\"unhandled address space\"" ]

[]

[ "<s>", "void", "mips_restore_gp_from_cprestore_slot", "(", "rtx", "temp", ")", "{", "gcc_assert", "(", "TARGET_ABICALLS", "&&", "TARGET_OLDABI", "&&", "epilogue_completed", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "must_restore_gp_when_clobbered_p", ")", "{", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "return", ";", "}", "if", "(", "TARGET_MIPS16", ")", "{", "mips_emit_move", "(", "temp", ",", "mips_cprestore_slot", "(", "temp", ",", "true", ")", ")", ";", "mips_emit_move", "(", "pic_offset_table_rtx", ",", "temp", ")", ";", "}", "else", "mips_emit_move", "(", "pic_offset_table_rtx", ",", "mips_cprestore_slot", "(", "temp", ",", "true", ")", ")", ";", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Restore", "$", "gp", "from", "its", "save", "slot", ",", "using", "TEMP", "as", "a", "temporary", "base", "register", "if", "need", "be", ".", "This", "function", "is", "for", "o32", "and", "o64", "abicalls", "only", ".", "See", "mips_must_initialize_gp_p", "for", "details", "about", "how", "we", "manage", "the", "global", "pointer", "." ]

[ "mips" ]

[]

[ "<s>", "void", "CustomListScheduler", "::", "Schedule", "(", ")", "{", "HazardRec", "->", "Reset", "(", ")", ";", "BuildSchedGraph", "(", "AA", ")", ";", "if", "(", "AntiDepBreak", "!=", "NULL", ")", "{", "unsigned", "Broken", "=", "AntiDepBreak", "->", "BreakAntiDependencies", "(", "SUnits", ",", "Begin", ",", "InsertPos", ",", "InsertPosIndex", ")", ";", "if", "(", "Broken", "!=", "0", ")", "{", "SUnits", ".", "clear", "(", ")", ";", "Sequence", ".", "clear", "(", ")", ";", "EntrySU", "=", "SUnit", "(", ")", ";", "ExitSU", "=", "SUnit", "(", ")", ";", "BuildSchedGraph", "(", "AA", ")", ";", "NumFixedAnti", "+=", "Broken", ";", "}", "}", "BuildSchedGraph", "(", "AA", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** List Scheduling **********\\n\"", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "AvailableQueue", ".", "initNodes", "(", "SUnits", ")", ";", "ListScheduleBottomUp", "(", ")", ";", "AvailableQueue", ".", "releaseState", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "Order", "nodes", "according", "to", "selected", "style", ",", "filling", "in", "the", "Sequence", "member", "." ]

[ "TMS320C64X", "0", "\"********** List Scheduling **********\\n\"", "0" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "this", "->", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "SNES" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "2", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "MBlaze", "2" ]

[]

[ "<s>", "void", "mips_declare_object_name", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"object\"", ")", ";", "size_directive_output", "=", "0", ";", "if", "(", "!", "flag_inhibit_size_directive", "&&", "DECL_SIZE", "(", "decl", ")", ")", "{", "HOST_WIDE_INT", "size", ";", "size_directive_output", "=", "1", ";", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "ASM_OUTPUT_SIZE_DIRECTIVE", "(", "stream", ",", "name", ",", "size", ")", ";", "}", "mips_declare_object", "(", "stream", ",", "name", ",", "\"\"", ",", "\":\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_DECLARE_OBJECT_NAME", ".", "This", "is", "like", "most", "of", "the", "standard", "ELF", "definitions", "except", "that", "it", "uses", "mips_declare_object", "(", ")", "to", "emit", "the", "label", "." ]

[ "mips", "\"object\"", "0", "1", "\"\"", "\":\\n\"" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "case", "Mips", "::", "CONSTPOOL_ENTRY", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "Mips", "Mips", "0", "Mips::CONSTPOOL_ENTRY", "2" ]

[]

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

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

[ "AArch64", "127", "128" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "!", "TM", ".", "getXCOFFTracebackTable", "(", ")", ")", "return", ";", "emitTracebackTable", "(", ")", ";", "if", "(", "!", "TargetLoweringObjectFileXCOFF", "::", "ShouldEmitEHBlock", "(", "MF", ")", "&&", "(", "getNumberOfVRSaved", "(", ")", ">", "0", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getCompactUnwindSection", "(", ")", ")", ";", "MCSymbol", "*", "EHInfoLabel", "=", "TargetLoweringObjectFileXCOFF", "::", "getEHInfoTableSymbol", "(", "MF", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EHInfoLabel", ")", ";", "OutStreamer", "->", "emitInt32", "(", "0", ")", ";", "const", "DataLayout", "&", "DL", "=", "MMI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "const", "unsigned", "PointerSize", "=", "DL", ".", "getPointerSize", "(", ")", ";", "OutStreamer", "->", "emitValueToAlignment", "(", "PointerSize", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "0", ",", "PointerSize", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "0", ",", "PointerSize", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "MF", "->", "getSection", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "PowerPC", "PPC", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "new", "X86ExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createX86IndirectBranchTrackingPass", "(", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "}", "addPass", "(", "createX86DiscriminateMemOpsPass", "(", ")", ")", ";", "addPass", "(", "createX86InsertPrefetchPass", "(", ")", ")", ";", "addPass", "(", "createX86InsertX87waitPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "rs6000_address_for_altivec", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "!", "altivec_indexed_or_indirect_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "if", "(", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", ")", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "addr", "=", "gen_rtx_AND", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "-", "16", ")", ")", ";", "x", "=", "change_address", "(", "x", ",", "GET_MODE", "(", "x", ")", ",", "addr", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Given", "a", "memory", "reference", ",", "if", "it", "is", "not", "in", "the", "form", "for", "altivec", "memory", "reference", "instructions", "(", "i.e", ".", "reg", "or", "reg+reg", "addressing", "with", "AND", "of", "-16", ")", ",", "convert", "to", "the", "altivec", "format", "." ]

[ "rs6000", "0", "16" ]

[]

[ "<s>", "const", "F2003fSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "isMemImm", "(", ")", "||", "isMemRegImm", "(", ")", "||", "isMemRegReg", "(", ")", ";", "}", "</s>" ]

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

[ "Lanai" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Expand Condsets\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Expand Condsets\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isBinOp", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "ANDNP", ":", "case", "X86ISD", "::", "PCMPGT", ":", "case", "X86ISD", "::", "FMAX", ":", "case", "X86ISD", "::", "FMIN", ":", "case", "X86ISD", "::", "FANDN", ":", "return", "true", ";", "}", "return", "TargetLoweringBase", "::", "isBinOp", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Add", "x86-specific", "opcodes", "to", "the", "default", "list", "." ]

[ "X86", "X86", "X86ISD::ANDNP", "X86ISD::PCMPGT", "X86ISD::FMAX", "X86ISD::FMIN", "X86ISD::FANDN" ]

[]

[ "<s>", "static", "rtx", "alphaev4_next_group", "(", "rtx", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev4_pipe", "pipe", ";", "pipe", "=", "alphaev4_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV4_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV4_IBX", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "else", "in_use", "|=", "EV4_IB0", "|", "EV4_IBX", ";", "break", ";", "case", "EV4_IB0", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV4_IBX", ")", "||", "(", "in_use", "&", "EV4_IB1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "in_use", "|=", "EV4_IB0", ";", "break", ";", "case", "EV4_IB1", ":", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>" ]

[ "IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev4_pipe", "above", ".", "If", "EV4_IBX", "is", "set", ",", "then", "the", "insn", "in", "EV4_IB0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV4_IB1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "." ]

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

[]

[ "<s>", "initialize_trampoline", "(", "TRAMP", ",", "FNADDR", ",", "CXT", ")", "{", "{", "ARG_POINTER_REGNUM", ",", "STACK_POINTER_REGNUM", "}", ",", "\\", "{", "ARG_POINTER_REGNUM", ",", "FRAME_POINTER_REGNUM", "}", ",", "\\", "{", "FRAME_POINTER_REGNUM", ",", "STACK_POINTER_REGNUM", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "TRAMP", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "bfin" ]

[]

[ "<s>", "static", "void", "push_csky_minipool_barrier", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ")", "{", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "that", "there", "is", "a", "natural", "barrier", "in", "the", "insn", "stream", "at", "ADDRESS", "." ]

[ "csky" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VSELECT", ":", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformAddCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSubCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "ADC", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "PerformSINT_TO_FPCombine", "(", "N", ",", "DAG", ",", "this", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "PerformFADDCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "PerformFSUBCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFPS", ":", "case", "X86ISD", "::", "SHUFPD", ":", "case", "X86ISD", "::", "PALIGN", ":", "case", "X86ISD", "::", "PUNPCKH", ":", "case", "X86ISD", "::", "UNPCKHP", ":", "case", "X86ISD", "::", "PUNPCKL", ":", "case", "X86ISD", "::", "UNPCKLP", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "X86ISD", "::", "VPERMILP", ":", "case", "X86ISD", "::", "VPERM2X128", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "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", "." ]

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::VSELECT", "ISD::SELECT", "X86ISD::CMOV", "ISD::ADD", "ISD::SUB", "X86ISD::ADC", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::LOAD", "ISD::STORE", "ISD::SINT_TO_FP", "ISD::FADD", "ISD::FSUB", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "X86ISD::SETCC", "X86ISD::SHUFPS", "X86ISD::SHUFPD", "X86ISD::PALIGN", "X86ISD::PUNPCKH", "X86ISD::UNPCKHP", "X86ISD::PUNPCKL", "X86ISD::UNPCKLP", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "X86ISD::VPERMILP", "X86ISD::VPERM2X128", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setSpecialOperandAttr", "(", "MachineInstr", "&", "OldMI1", ",", "MachineInstr", "&", "OldMI2", ",", "MachineInstr", "&", "NewMI1", ",", "MachineInstr", "&", "NewMI2", ")", "const", "{", "uint16_t", "IntersectedFlags", "=", "OldMI1", ".", "getFlags", "(", ")", "&", "OldMI2", ".", "getFlags", "(", ")", ";", "NewMI1", ".", "setFlags", "(", "IntersectedFlags", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoSWrap", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoUWrap", ")", ";", "NewMI1", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "IsExact", ")", ";", "NewMI2", ".", "setFlags", "(", "IntersectedFlags", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoSWrap", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "NoUWrap", ")", ";", "NewMI2", ".", "clearFlag", "(", "MachineInstr", "::", "MIFlag", "::", "IsExact", ")", ";", "MachineOperand", "*", "OldFlagDef1", "=", "OldMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "OldFlagDef2", "=", "OldMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "!", "OldFlagDef1", "==", "!", "OldFlagDef2", "&&", "\"Unexpected instruction type for reassociation\"", ")", ";", "if", "(", "!", "OldFlagDef1", "||", "!", "OldFlagDef2", ")", "return", ";", "assert", "(", "OldFlagDef1", "->", "isDead", "(", ")", "&&", "OldFlagDef2", "->", "isDead", "(", ")", "&&", "\"Must have dead EFLAGS operand in reassociable instruction\"", ")", ";", "MachineOperand", "*", "NewFlagDef1", "=", "NewMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "NewFlagDef2", "=", "NewMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "NewFlagDef1", "&&", "NewFlagDef2", "&&", "\"Unexpected operand in reassociable instruction\"", ")", ";", "NewFlagDef1", "->", "setIsDead", "(", ")", ";", "NewFlagDef2", "->", "setIsDead", "(", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "architecture-specific", "helper", "function", "of", "reassociateOps", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::EFLAGS", "\"Unexpected instruction type for reassociation\"", "\"Must have dead EFLAGS operand in reassociable instruction\"", "X86::EFLAGS", "X86::EFLAGS", "\"Unexpected operand in reassociable instruction\"" ]

[]

[ "<s>", "void", "DataFlowGraph", "::", "reset", "(", ")", "{", "Memory", ".", "clear", "(", ")", ";", "Func", "=", "NodeAddr", "<", "FuncNode", "*", ">", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "SIPreEmitPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBE", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBE", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBE", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_CBRANCH_VCCZ", ":", "case", "AMDGPU", "::", "S_CBRANCH_VCCNZ", ":", "Changed", "|=", "optimizeVccBranch", "(", "MI", ")", ";", "continue", ";", "default", ":", "break", ";", "}", "}", "if", "(", "!", "ST", ".", "hasVGPRIndexMode", "(", ")", ")", "continue", ";", "MachineInstr", "*", "SetGPRMI", "=", "nullptr", ";", "const", "unsigned", "Threshold", "=", "20", ";", "unsigned", "Count", "=", "0", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MBBI", "!=", "MBBE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "++", "MBBI", ";", "if", "(", "Count", "==", "Threshold", ")", "SetGPRMI", "=", "nullptr", ";", "else", "++", "Count", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "S_SET_GPR_IDX_ON", ")", "continue", ";", "Count", "=", "0", ";", "if", "(", "!", "SetGPRMI", ")", "{", "SetGPRMI", "=", "&", "MI", ";", "continue", ";", "}", "if", "(", "optimizeSetGPR", "(", "*", "SetGPRMI", ",", "MI", ")", ")", "Changed", "=", "true", ";", "else", "SetGPRMI", "=", "&", "MI", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_CBRANCH_VCCZ", "AMDGPU::S_CBRANCH_VCCNZ", "20", "0", "AMDGPU::S_SET_GPR_IDX_ON", "0" ]

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "HEXAGON_RESERVED_REG_1", ")", ";", "Reserved", ".", "set", "(", "HEXAGON_RESERVED_REG_2", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "D14", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "D15", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::PC", "Hexagon::GP", "Hexagon::D14", "Hexagon::D15", "Hexagon::LC0", "Hexagon::LC1", "Hexagon::SA0", "Hexagon::SA1" ]

[]

[ "<s>", "enum", "reg_class", "class_likely_spilled_p", "(", "int", "c", ")", "{", "return", "(", "c", "!=", "ALL_REGS", "&&", "c", "!=", "ADDW_REGS", ")", ";", "}", "</s>" ]

[ "Return", "value", "is", "nonzero", "if", "pseudos", "that", "have", "been", "assigned", "to", "registers", "of", "class", "CLASS", "would", "likely", "be", "spilled", "because", "registers", "of", "CLASS", "are", "needed", "for", "spill", "registers", "." ]

[ "avr" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "isTriviallyReMaterializable", "(", "MI", ",", "AA", ")", ";", "case", "AMDGPU", "::", "S_MOV_B32", ":", "case", "AMDGPU", "::", "S_MOV_B64", ":", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "trivially", "rematerializable", ",", "meaning", "it", "has", "no", "side", "effects", "and", "requires", "no", "operands", "that", "are", "n't", "always", "available", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU::S_MOV_B32", "AMDGPU::S_MOV_B64", "AMDGPU::V_MOV_B32_e32", "1" ]

[]

[ "<s>", "static", "void", "mmix_emit_sp_add", "(", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "insn", ";", "if", "(", "offset", "<", "0", ")", "{", "if", "(", "offset", ">", "-", "255", ")", "insn", "=", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "else", "{", "rtx", "tmpr", "=", "gen_rtx_REG", "(", "DImode", ",", "255", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_move_insn", "(", "tmpr", ",", "GEN_INT", "(", "offset", ")", ")", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmpr", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "if", "(", "insn_const_int_ok_for_constraint", "(", "offset", ",", "CONSTRAINT_L", ")", ")", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "else", "{", "rtx", "tmpr", "=", "gen_rtx_REG", "(", "DImode", ",", "255", ")", ";", "emit_move_insn", "(", "tmpr", ",", "GEN_INT", "(", "offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmpr", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Local", "(", "static", ")", "helper", "functions", "." ]

[ "mmix", "0", "255", "255", "1", "1", "255" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", ".", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "R4", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "R4", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBBJ", ":", "llvm", "::", "drop_begin", "(", "MF", ")", ")", "MBBJ", ".", "addLiveIn", "(", "MSP430", "::", "R4", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "MSP430", "MSP430", "\"Shrink-wrapping not yet supported\"", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::R4", "MSP430::MOV16rr", "MSP430::R4", "MSP430::SP", "MSP430::R4", "MSP430", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", ".", "hasAVX512", "(", ")", "?", "MVT", "::", "i1", ":", "MVT", "::", "i8", ";", "if", "(", "VT", ".", "isSimple", "(", ")", ")", "{", "MVT", "VVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VVT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltVT", "=", "VVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VVT", ".", "is512BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "case", "64", ":", "return", "MVT", "::", "v64i1", ";", "}", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "NumElts", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", "&&", "getTypeAction", "(", "Context", ",", "VT", ")", "==", "TypePromoteInteger", ")", "{", "EVT", "LegalVT", "=", "getTypeToTransformTo", "(", "Context", ",", "VT", ")", ";", "EltVT", "=", "LegalVT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "}", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "EltVT", ".", "getSizeInBits", "(", ")", ">=", "32", ")", "switch", "(", "NumElts", ")", "{", "case", "2", ":", "return", "MVT", "::", "v2i1", ";", "case", "4", ":", "return", "MVT", "::", "v4i1", ";", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "X86", "X86", "MVT::i1", "MVT::i8", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "8", "MVT::v8i1", "16", "MVT::v16i1", "MVT::i8", "MVT::i16", "32", "MVT::v32i1", "64", "MVT::v64i1", "MVT::getVectorVT", "MVT::i1", "32", "2", "MVT::v2i1", "4", "MVT::v4i1", "8", "MVT::v8i1" ]

[]

[ "<s>", "static", "void", "vax_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "*", "cum", "+=", "(", "mode", "!=", "BLKmode", "?", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "&", "~", "3", ":", "(", "int_size_in_bytes", "(", "type", ")", "+", "3", ")", "&", "~", "3", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "vax", "3", "3", "3", "3" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "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", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "if", "(", "is64Bit", "(", ")", ")", "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_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "\"SystemZ does do not have assembler relaxation\"", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ does do not have assembler relaxation\"" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADDE", ":", "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "Val", "=", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Val", "=", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ")", ";", "case", "ISD", "::", "SHL", ":", "Val", "=", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "Val", "=", "performXORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SETCC", ":", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nMipsSE DAG Combine:\\n\"", ";", "N", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n=> \\n\"", ";", "Val", ".", "getNode", "(", ")", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Val", ";", "}", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</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::ADDE", "ISD::AND", "ISD::OR", "ISD::SUBE", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::XOR", "ISD::SETCC", "\"\\nMipsSE DAG Combine:\\n\"", "\"\\n=> \\n\"", "\"\\n\"", "Mips" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "case", "RISCVISD", "::", "ROLW", ":", "case", "RISCVISD", "::", "RORW", ":", "case", "RISCVISD", "::", "GREVW", ":", "case", "RISCVISD", "::", "GORCW", ":", "case", "RISCVISD", "::", "FSLW", ":", "case", "RISCVISD", "::", "FSRW", ":", "case", "RISCVISD", "::", "SHFLW", ":", "case", "RISCVISD", "::", "UNSHFLW", ":", "case", "RISCVISD", "::", "BCOMPRESSW", ":", "case", "RISCVISD", "::", "BDECOMPRESSW", ":", "return", "33", ";", "case", "RISCVISD", "::", "SHFL", ":", "case", "RISCVISD", "::", "UNSHFL", ":", "{", "if", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "&&", "(", "Op", ".", "getConstantOperandVal", "(", "1", ")", "&", "0x10", ")", "==", "0", ")", "{", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "if", "(", "Tmp", ">", "32", ")", "return", "33", ";", "}", "break", ";", "}", "case", "RISCVISD", "::", "VMV_X_S", ":", "if", "(", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "1", ";", "return", "Subtarget", ".", "getXLen", "(", ")", "-", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", "+", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "RISCV", "RISCV", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "RISCVISD::ROLW", "RISCVISD::RORW", "RISCVISD::GREVW", "RISCVISD::GORCW", "RISCVISD::FSLW", "RISCVISD::FSRW", "RISCVISD::SHFLW", "RISCVISD::UNSHFLW", "RISCVISD::BCOMPRESSW", "RISCVISD::BDECOMPRESSW", "33", "RISCVISD::SHFL", "RISCVISD::UNSHFL", "MVT::i64", "1", "1", "0x10", "0", "0", "1", "32", "33", "RISCVISD::VMV_X_S", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Delay Slot Filler\"" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "OS", ".", "flush", "(", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "Mips", "0" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "bool", "M88kAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IdLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "FeatureBitset", "MissingFeatures", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IdLoc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IdLoc", ",", "\"Instruction use requires option to be enabled\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IdLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IdLoc", ",", "\"Too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "M88kOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"Invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "M88kOperand", "&", "Op", "=", "static_cast", "<", "M88kOperand", "&", ">", "(", "*", "Operands", "[", "0", "]", ")", ";", "std", "::", "string", "Suggestion", "=", "M88kMnemonicSpellCheck", "(", "Op", ".", "getToken", "(", ")", ",", "FBS", ",", "0", ")", ";", "return", "Error", "(", "IdLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ")", ";", "}", "}", "if", "(", "MatchResult", ">", "FIRST_TARGET_MATCH_RESULT_TY", ")", "{", "SMLoc", "ErrorLoc", "=", "IdLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", "&&", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "switch", "(", "MatchResult", ")", "{", "case", "Match_InvalidBitfield", ":", "case", "Match_InvalidBitfieldWidth", ":", "case", "Match_InvalidBitfieldOffset", ":", "case", "Match_InvalidPixelRotationSize", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "M88kOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "getMatchKindDiag", "(", "(", "M88kMatchResultTy", ")", "MatchResult", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "M88k", "M88k", "\"Instruction use requires option to be enabled\"", "0U", "\"Too few operands for instruction\"", "M88k", "\"Invalid operand for instruction\"", "M88k", "M88k", "0", "M88k", "0", "\"invalid instruction\"", "0ULL", "\"too few operands for instruction\"", "M88k", "M88k", "\"Unexpected match type\"" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "ARCSubtarget", "::", "ARCSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "ARCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC", "ARC" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "MCAsmInfo", "*", "MCAI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "releaseMemory", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "placeMarkers", "(", "MF", ")", ";", "if", "(", "MCAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "Wasm", "&&", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "removeUnnecessaryInstrs", "(", "MF", ")", ";", "rewriteDepthImmediates", "(", "MF", ")", ";", "fixEndsAtEndOfFunction", "(", "MF", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "appendEndToFunction", "(", "MF", ",", "TII", ")", ";", "cleanupFunctionData", "(", "MF", ")", ";", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "setCFGStackified", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "P2PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "P2TargetMachine", "&", "TM", "=", "getP2TargetMachine", "(", ")", ";", "addPass", "(", "createP2ExpandPseudosPass", "(", "TM", ")", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "P2", "P2", "P2" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "if", "(", "!", "InBrackets", ")", "{", "MCB", ".", "clear", "(", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "HexagonOperand", "&", "FirstOperand", "=", "static_cast", "<", "HexagonOperand", "&", ">", "(", "*", "Operands", "[", "0", "]", ")", ";", "if", "(", "FirstOperand", ".", "isToken", "(", ")", "&&", "FirstOperand", ".", "getToken", "(", ")", "==", "\"{\"", ")", "{", "assert", "(", "Operands", ".", "size", "(", ")", "==", "1", "&&", "\"Brackets should be by themselves\"", ")", ";", "if", "(", "InBrackets", ")", "{", "getParser", "(", ")", ".", "Error", "(", "IDLoc", ",", "\"Already in a packet\"", ")", ";", "InBrackets", "=", "false", ";", "return", "true", ";", "}", "InBrackets", "=", "true", ";", "return", "false", ";", "}", "if", "(", "FirstOperand", ".", "isToken", "(", ")", "&&", "FirstOperand", ".", "getToken", "(", ")", "==", "\"}\"", ")", "{", "assert", "(", "Operands", ".", "size", "(", ")", "==", "1", "&&", "\"Brackets should be by themselves\"", ")", ";", "if", "(", "!", "InBrackets", ")", "{", "getParser", "(", ")", ".", "Error", "(", "IDLoc", ",", "\"Not in a packet\"", ")", ";", "return", "true", ";", "}", "InBrackets", "=", "false", ";", "if", "(", "matchBundleOptions", "(", ")", ")", "return", "true", ";", "return", "finishBundle", "(", "IDLoc", ",", "Out", ")", ";", "}", "MCInst", "*", "SubInst", "=", "new", "(", "getParser", "(", ")", ".", "getContext", "(", ")", ")", "MCInst", ";", "if", "(", "matchOneInstruction", "(", "*", "SubInst", ",", "IDLoc", ",", "Operands", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "if", "(", "InBrackets", ")", "eatToEndOfPacket", "(", ")", ";", "return", "true", ";", "}", "HexagonMCInstrInfo", "::", "extendIfNeeded", "(", "getParser", "(", ")", ".", "getContext", "(", ")", ",", "MII", ",", "MCB", ",", "*", "SubInst", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "SubInst", ")", ")", ";", "if", "(", "!", "InBrackets", ")", "return", "finishBundle", "(", "IDLoc", ",", "Out", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon", "Hexagon", "0", "\"{\"", "1", "\"Brackets should be by themselves\"", "\"Already in a packet\"", "\"}\"", "1", "\"Brackets should be by themselves\"", "\"Not in a packet\"", "Hexagon" ]

[]

[ "<s>", "static", "const", "char", "*", "generate_host_descr_file", "(", "const", "char", "*", "host_compiler", ")", "{", "char", "*", "dump_filename", "=", "concat", "(", "dumppfx", ",", "\"_host_descr.c\"", ",", "NULL", ")", ";", "const", "char", "*", "src_filename", "=", "save_temps", "?", "dump_filename", ":", "make_temp_file", "(", "\"_host_descr.c\"", ")", ";", "const", "char", "*", "obj_filename", "=", "save_temps", "?", "concat", "(", "dumppfx", ",", "\"_host_descr.o\"", ",", "NULL", ")", ":", "make_temp_file", "(", "\"_host_descr.o\"", ")", ";", "temp_files", "[", "num_temps", "++", "]", "=", "src_filename", ";", "temp_files", "[", "num_temps", "++", "]", "=", "obj_filename", ";", "FILE", "*", "src_file", "=", "fopen", "(", "src_filename", ",", "\"w\"", ")", ";", "if", "(", "!", "src_file", ")", "fatal_error", "(", "input_location", ",", "\"cannot open '%s'\"", ",", "src_filename", ")", ";", "fprintf", "(", "src_file", ",", "\"extern const void *const __OFFLOAD_TABLE__;\\n\"", "\"extern const void *const __offload_image_intelmic_start;\\n\"", "\"extern const void *const __offload_image_intelmic_end;\\n\\n\"", "\"static const void *const __offload_target_data[] = {\\n\"", "\" &__offload_image_intelmic_start, &__offload_image_intelmic_end\\n\"", "\"};\\n\\n\"", ")", ";", "fprintf", "(", "src_file", ",", "\"#ifdef __cplusplus\\n\"", "\"extern \\\"C\\\"\\n\"", "\"#endif\\n\"", "\"void GOMP_offload_register (const void *, int, const void *);\\n\"", "\"#ifdef __cplusplus\\n\"", "\"extern \\\"C\\\"\\n\"", "\"#endif\\n\"", "\"void GOMP_offload_unregister (const void *, int, const void *);\\n\\n\"", "\"__attribute__((constructor))\\n\"", "\"static void\\n\"", "\"init (void)\\n\"", "\"{\\n\"", "\" GOMP_offload_register (&__OFFLOAD_TABLE__, %d, __offload_target_data);\\n\"", "\"}\\n\\n\"", ",", "GOMP_DEVICE_INTEL_MIC", ")", ";", "fprintf", "(", "src_file", ",", "\"__attribute__((destructor))\\n\"", "\"static void\\n\"", "\"fini (void)\\n\"", "\"{\\n\"", "\" GOMP_offload_unregister (&__OFFLOAD_TABLE__, %d, __offload_target_data);\\n\"", "\"}\\n\"", ",", "GOMP_DEVICE_INTEL_MIC", ")", ";", "fclose", "(", "src_file", ")", ";", "struct", "obstack", "argv_obstack", ";", "obstack_init", "(", "&", "argv_obstack", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "host_compiler", ")", ";", "if", "(", "save_temps", ")", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-save-temps\"", ")", ";", "if", "(", "verbose", ")", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-v\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-dumpdir\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-dumpbase\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "dump_filename", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-dumpbase-ext\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\".c\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-c\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-fPIC\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-shared\"", ")", ";", "switch", "(", "offload_abi", ")", "{", "case", "OFFLOAD_ABI_LP64", ":", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-m64\"", ")", ";", "break", ";", "case", "OFFLOAD_ABI_ILP32", ":", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-m32\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "src_filename", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "\"-o\"", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "obj_filename", ")", ";", "obstack_ptr_grow", "(", "&", "argv_obstack", ",", "NULL", ")", ";", "char", "*", "*", "argv", "=", "XOBFINISH", "(", "&", "argv_obstack", ",", "char", "*", "*", ")", ";", "fork_execute", "(", "argv", "[", "0", "]", ",", "argv", ",", "false", ",", "NULL", ")", ";", "obstack_free", "(", "&", "argv_obstack", ",", "NULL", ")", ";", "return", "obj_filename", ";", "}", "</s>" ]

[ "Generates", "object", "file", "with", "the", "host", "side", "descriptor", "." ]

[ "i386", "\"_host_descr.c\"", "\"_host_descr.c\"", "\"_host_descr.o\"", "\"_host_descr.o\"", "\"w\"", "\"cannot open '%s'\"", "\"extern const void *const __OFFLOAD_TABLE__;\\n\"", "\"extern const void *const __offload_image_intelmic_start;\\n\"", "\"extern const void *const __offload_image_intelmic_end;\\n\\n\"", "\"static const void *const __offload_target_data[] = {\\n\"", "\" &__offload_image_intelmic_start, &__offload_image_intelmic_end\\n\"", "\"};\\n\\n\"", "\"#ifdef __cplusplus\\n\"", "\"extern \\\"C\\\"\\n\"", "\"#endif\\n\"", "\"void GOMP_offload_register (const void *, int, const void *);\\n\"", "\"#ifdef __cplusplus\\n\"", "\"extern \\\"C\\\"\\n\"", "\"#endif\\n\"", "\"void GOMP_offload_unregister (const void *, int, const void *);\\n\\n\"", "\"__attribute__((constructor))\\n\"", "\"static void\\n\"", "\"init (void)\\n\"", "\"{\\n\"", "\" GOMP_offload_register (&__OFFLOAD_TABLE__, %d, __offload_target_data);\\n\"", "\"}\\n\\n\"", "\"__attribute__((destructor))\\n\"", "\"static void\\n\"", "\"fini (void)\\n\"", "\"{\\n\"", "\" GOMP_offload_unregister (&__OFFLOAD_TABLE__, %d, __offload_target_data);\\n\"", "\"}\\n\"", "\"-save-temps\"", "\"-v\"", "\"-dumpdir\"", "\"\"", "\"-dumpbase\"", "\"-dumpbase-ext\"", "\".c\"", "\"-c\"", "\"-fPIC\"", "\"-shared\"", "\"-m64\"", "\"-m32\"", "\"-o\"", "0" ]

[]

[ "<s>", "static", "void", "macho_branch_islands", "(", "void", ")", "{", "char", "tmp_buf", "[", "512", "]", ";", "while", "(", "!", "vec_safe_is_empty", "(", "branch_islands", ")", ")", "{", "branch_island", "*", "bi", "=", "&", "branch_islands", "->", "last", "(", ")", ";", "const", "char", "*", "label", "=", "IDENTIFIER_POINTER", "(", "bi", "->", "label_name", ")", ";", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "bi", "->", "function_name", ")", ";", "char", "name_buf", "[", "512", "]", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", "||", "name", "[", "0", "]", "==", "'&'", ")", "strcpy", "(", "name_buf", ",", "name", "+", "1", ")", ";", "else", "{", "name_buf", "[", "0", "]", "=", "'_'", ";", "strcpy", "(", "name_buf", "+", "1", ",", "name", ")", ";", "}", "strcpy", "(", "tmp_buf", ",", "\"\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "dbxout_stabd", "(", "N_SLINE", ",", "bi", "->", "line_number", ")", ";", "if", "(", "flag_pic", ")", "{", "strcat", "(", "tmp_buf", ",", "\":\\n\\tmflr r0\\n\\tbcl 20,31,\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic:\\n\\tmflr r11\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\taddis r11,r11,ha16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\" - \"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic)\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\tmtlr r0\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\taddi r12,r11,lo16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\" - \"", ")", ";", "strcat", "(", "tmp_buf", ",", "label", ")", ";", "strcat", "(", "tmp_buf", ",", "\"_pic)\\n\"", ")", ";", "strcat", "(", "tmp_buf", ",", "\"\\tmtctr r12\\n\\tbctr\\n\"", ")", ";", "}", "else", "{", "strcat", "(", "tmp_buf", ",", "\":\\n\\tlis r12,hi16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tori r12,r12,lo16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "name_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tmtctr r12\\n\\tbctr\"", ")", ";", "}", "output_asm_insn", "(", "tmp_buf", ",", "0", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "dbxout_stabd", "(", "N_SLINE", ",", "bi", "->", "line_number", ")", ";", "branch_islands", "->", "pop", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "far-jump", "branch", "islands", "for", "everything", "on", "the", "branch_island_list", ".", "Invoked", "immediately", "after", "the", "last", "instruction", "of", "the", "epilogue", "has", "been", "emitted", ";", "the", "branch-islands", "must", "be", "appended", "to", ",", "and", "contiguous", "with", ",", "the", "function", "body", ".", "Mach-O", "stubs", "are", "generated", "in", "machopic_output_stub", "(", ")", "." ]

[ "rs6000", "512", "512", "0", "0", "1", "0", "1", "\"\\n\"", "\":\\n\\tmflr r0\\n\\tbcl 20,31,\"", "\"_pic\\n\"", "\"_pic:\\n\\tmflr r11\\n\"", "\"\\taddis r11,r11,ha16(\"", "\" - \"", "\"_pic)\\n\"", "\"\\tmtlr r0\\n\"", "\"\\taddi r12,r11,lo16(\"", "\" - \"", "\"_pic)\\n\"", "\"\\tmtctr r12\\n\\tbctr\\n\"", "\":\\n\\tlis r12,hi16(\"", "\")\\n\\tori r12,r12,lo16(\"", "\")\\n\\tmtctr r12\\n\\tbctr\"", "0" ]

[]

[ "<s>", "static", "bool", "mips_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_SIBCALLS", ";", "}", "</s>" ]

[ "We", "can", "handle", "any", "sibcall", "when", "TARGET_SIBCALLS", "is", "true", "." ]

[ "mips" ]

[]

[ "<s>", "void", "dimode_scalar_chain", "::", "make_vector_copies", "(", "unsigned", "regno", ")", "{", "rtx", "reg", "=", "regno_reg_rtx", "[", "regno", "]", ";", "rtx", "vreg", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "df_ref", "ref", ";", "for", "(", "ref", "=", "DF_REG_DEF_CHAIN", "(", "regno", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "if", "(", "!", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "start_sequence", "(", ")", ";", "if", "(", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", "{", "rtx", "tmp", "=", "assign_386_stack_local", "(", "DImode", ",", "SLOT_STV_TEMP", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tmp", ",", "SImode", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tmp", ",", "SImode", ",", "4", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ")", ";", "emit_move_insn", "(", "vreg", ",", "tmp", ")", ";", "}", "else", "if", "(", "TARGET_SSE4_1", ")", "{", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_sse4_1_pinsrd", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ",", "GEN_INT", "(", "2", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_sse2_loadld", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "tmp", ",", "0", ")", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "4", ")", ")", ")", ";", "emit_insn", "(", "gen_vec_interleave_lowv4si", "(", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "vreg", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "tmp", ",", "0", ")", ")", ")", ";", "}", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "rtx_insn", "*", "insn", "=", "DF_REF_INSN", "(", "ref", ")", ";", "emit_conversion_insns", "(", "seq", ",", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Copied r%d to a vector register r%d for insn %d\\n\"", ",", "regno", ",", "REGNO", "(", "vreg", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "for", "(", "ref", "=", "DF_REG_USE_CHAIN", "(", "regno", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "if", "(", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "rtx_insn", "*", "insn", "=", "DF_REF_INSN", "(", "ref", ")", ";", "replace_with_subreg_in_insn", "(", "insn", ",", "reg", ",", "vreg", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Replaced r%d with r%d in insn %d\\n\"", ",", "regno", ",", "REGNO", "(", "vreg", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]

[ "Make", "vector", "copies", "for", "all", "register", "REGNO", "definitions", "and", "replace", "its", "uses", "in", "a", "chain", "." ]

[ "i386", "0", "0", "4", "4", "0", "0", "0", "0", "4", "2", "0", "0", "0", "4", "0", "0", "0", "\" Copied r%d to a vector register r%d for insn %d\\n\"", "\" Replaced r%d with r%d in insn %d\\n\"" ]

[]

[ "<s>", "unsigned", "CAHPInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "CAHPTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "CAHP", "CAHP", "0", "CAHP", "0" ]

[]

[ "<s>", "void", "function_expander", "::", "add_input_operand", "(", "insn_code", "icode", ",", "rtx", "x", ")", "{", "unsigned", "int", "opno", "=", "m_ops", ".", "length", "(", ")", ";", "const", "insn_operand_data", "&", "operand", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "opno", "]", ";", "machine_mode", "mode", "=", "operand", ".", "mode", ";", "if", "(", "mode", "==", "VOIDmode", ")", "{", "gcc_assert", "(", "operand", ".", "predicate", "==", "aarch64_any_register_operand", ")", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "}", "else", "if", "(", "!", "VECTOR_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", "&&", "VECTOR_MODE_P", "(", "mode", ")", ")", "x", "=", "expand_vector_broadcast", "(", "mode", ",", "x", ")", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_BOOL", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "x", ")", "==", "VNx16BImode", ")", ";", "x", "=", "gen_lowpart", "(", "mode", ",", "x", ")", ";", "}", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ",", "true", ")", ";", "create_input_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Create", "op", "and", "add", "it", "into", "M_OPS", "and", "increase", "OPNO", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "addInstruction", "(", "MachineInstr", "*", "I", ")", "{", "Instrs", ".", "push_back", "(", "I", ")", ";", "}", "</s>" ]

[ "Record", "pressure", "difference", "induced", "by", "the", "given", "operand", "list", "to", "node", "with", "index", "Idx", "." ]

[ "X86" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "unsigned", "AArch64Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", "&&", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "auto", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "UseNonLazyBind", "&&", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", "&&", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG" ]

[]

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

[ "Enable", "the", "use", "of", "the", "early", "if", "conversion", "pass", "." ]

[ "SystemZ" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::VASTART" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "orderFrameObjects", "(", "const", "MachineFunction", "&", "MF", ",", "SmallVectorImpl", "<", "int", ">", "&", "ObjectsToAllocate", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "ObjectsToAllocate", ".", "empty", "(", ")", ")", "return", ";", "std", "::", "vector", "<", "X86FrameSortingObject", ">", "SortingObjects", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ")", ";", "for", "(", "auto", "&", "Obj", ":", "ObjectsToAllocate", ")", "{", "SortingObjects", "[", "Obj", "]", ".", "IsValid", "=", "true", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectIndex", "=", "Obj", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectAlignment", "=", "MFI", ".", "getObjectAlignment", "(", "Obj", ")", ";", "int", "ObjectSize", "=", "MFI", ".", "getObjectSize", "(", "Obj", ")", ";", "if", "(", "ObjectSize", "==", "0", ")", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "4", ";", "else", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "ObjectSize", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isFI", "(", ")", ")", "continue", ";", "int", "Index", "=", "MO", ".", "getIndex", "(", ")", ";", "if", "(", "Index", ">=", "0", "&&", "Index", "<", "MFI", ".", "getObjectIndexEnd", "(", ")", "&&", "SortingObjects", "[", "Index", "]", ".", "IsValid", ")", "SortingObjects", "[", "Index", "]", ".", "ObjectNumUses", "++", ";", "}", "}", "}", "std", "::", "stable_sort", "(", "SortingObjects", ".", "begin", "(", ")", ",", "SortingObjects", ".", "end", "(", ")", ",", "X86FrameSortingComparator", "(", ")", ")", ";", "int", "i", "=", "0", ";", "for", "(", "auto", "&", "Obj", ":", "SortingObjects", ")", "{", "if", "(", "!", "Obj", ".", "IsValid", ")", "break", ";", "ObjectsToAllocate", "[", "i", "++", "]", "=", "Obj", ".", "ObjectIndex", ";", "}", "if", "(", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "hasFP", "(", "MF", ")", ")", "std", "::", "reverse", "(", "ObjectsToAllocate", ".", "begin", "(", ")", ",", "ObjectsToAllocate", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Order", "the", "symbols", "in", "the", "local", "stack", "." ]

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

[]

[ "<s>", "void", "M88kInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "NewDestBB", ",", "MachineBasicBlock", "&", "RestoreBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "M88k", "::", "GPRRCRegClass", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M88k", "::", "ORriu", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addReg", "(", "M88k", "::", "R0", ")", ".", "addMBB", "(", "&", "NewDestBB", ",", "M88kII", "::", "MO_ABS_HI", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M88k", "::", "ORri", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addMBB", "(", "&", "NewDestBB", ",", "M88kII", "::", "MO_ABS_LO", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M88k", "::", "JMP", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "M88k", "::", "GPRRCRegClass", ",", "MI", "->", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "assert", "(", "Scav", "!=", "M88k", "::", "NoRegister", "&&", "\"No register is scavenged!\"", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "M88k", "M88k", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "M88k::GPRRCRegClass", "M88k::ORriu", "M88k::R0", "M88kII::MO_ABS_HI", "M88k::ORri", "M88kII::MO_ABS_LO", "M88k::JMP", "M88k::GPRRCRegClass", "0", "M88k::NoRegister", "\"No register is scavenged!\"" ]

[]

[ "<s>", "const", "char", "*", "F2003fTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "F2003fISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "F2003fISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "F2003fISD", "::", "Wrapper", ":", "return", "\"F2003fISD::Wrapper\"", ";", "case", "F2003fISD", "::", "FENXEO", ":", "return", "\"F2003fISD::FENXEO\"", ";", "case", "F2003fISD", "::", "DOSNUD", ":", "return", "\"F2003fISD::DOSNUD\"", ";", "case", "F2003fISD", "::", "SELECT_CC", ":", "return", "\"F2003fISD::SELECT_CC\"", ";", "case", "F2003fISD", "::", "BR_CC", ":", "return", "\"F2003fISD::BR_CC\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003fISD::NodeType", "F2003fISD::FIRST_NUMBER", "F2003fISD::Wrapper", "\"F2003fISD::Wrapper\"", "F2003fISD::FENXEO", "\"F2003fISD::FENXEO\"", "F2003fISD::DOSNUD", "\"F2003fISD::DOSNUD\"", "F2003fISD::SELECT_CC", "\"F2003fISD::SELECT_CC\"", "F2003fISD::BR_CC", "\"F2003fISD::BR_CC\"" ]

[]

[ "<s>", "bool", "Mips16TargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "MipsCC", "&", "MipsCCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "MipsFunctionInfo", "&", "FI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

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

[]

[ "<s>", "static", "rtx", "frame_emit_store", "(", "int", "regno", ",", "int", "regno_note", ",", "rtx", "addr", ",", "rtx", "cfa", ",", "int", "cfa_offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "rtx", "mov", "=", "gen_movsi", "(", "mem", ",", "reg", ")", ";", "rtx", "reg_note", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno_note", ")", ";", "rtx", "cfa_relative_addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "cfa", ",", "gen_int_si", "(", "cfa_offset", ")", ")", ";", "rtx", "cfa_relative_mem", "=", "gen_frame_mem", "(", "Pmode", ",", "cfa_relative_addr", ")", ";", "rtx", "real", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "cfa_relative_mem", ",", "reg_note", ")", ";", "add_reg_note", "(", "mov", ",", "REG_CFA_OFFSET", ",", "real", ")", ";", "return", "emit_insn", "(", "mov", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "in", "the", "stack", "frame", "to", "save", "REGNO", "at", "address", "ADDR", ",", "and", "emit", "the", "corresponding", "REG_CFA_OFFSET", "note", "described", "by", "CFA", "and", "CFA_OFFSET", ".", "Return", "the", "emitted", "insn", "." ]

[ "tilepro" ]

[]

[ "<s>", "int", "rs6000_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ";", "rtx", "out_pat", ",", "in_pat", ";", "rtx", "out_exp", ",", "in_exp", ";", "int", "i", ",", "j", ";", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "{", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_set", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "i", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "else", "{", "in_pat", "=", "PATTERN", "(", "in_insn", ")", ";", "if", "(", "GET_CODE", "(", "in_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "in_pat", ",", "0", ")", ";", "i", "++", ")", "{", "in_exp", "=", "XVECEXP", "(", "in_pat", ",", "0", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "in_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "in_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "in_exp", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_exp", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "j", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "j", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "return", "store_data_bypass_p", "(", "out_insn", ",", "in_insn", ")", ";", "}", "</s>" ]

[ "Given", "that", "there", "exists", "at", "least", "one", "variable", "that", "is", "set", "(", "produced", ")", "by", "OUT_INSN", "and", "read", "(", "consumed", ")", "by", "IN_INSN", ",", "return", "true", "iff", "IN_INSN", "represents", "one", "or", "more", "memory", "store", "operations", "and", "none", "of", "the", "variables", "set", "by", "OUT_INSN", "is", "used", "by", "IN_INSN", "as", "the", "address", "of", "a", "store", "operation", ".", "If", "either", "IN_INSN", "or", "OUT_INSN", "does", "not", "represent", "a", "``", "single", "''", "RTL", "SET", "expression", "(", "as", "loosely", "defined", "by", "the", "implementation", "of", "the", "single_set", "function", ")", "or", "a", "PARALLEL", "with", "only", "SETs", ",", "CLOBBERs", ",", "and", "USEs", "inside", ",", "this", "function", "returns", "false", ".", "This", "rs6000-specific", "version", "of", "store_data_bypass_p", "checks", "for", "certain", "conditions", "that", "result", "in", "assertion", "failures", "(", "and", "internal", "compiler", "errors", ")", "in", "the", "generic", "store_data_bypass_p", "function", "and", "returns", "false", "rather", "than", "calling", "store_data_bypass_p", "if", "one", "of", "the", "problematic", "conditions", "is", "detected", "." ]

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

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "MipsInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "MipsII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"mips-got\"", "}", ",", "{", "MO_GOT_CALL", ",", "\"mips-got-call\"", "}", ",", "{", "MO_GPREL", ",", "\"mips-gprel\"", "}", ",", "{", "MO_ABS_HI", ",", "\"mips-abs-hi\"", "}", ",", "{", "MO_ABS_LO", ",", "\"mips-abs-lo\"", "}", ",", "{", "MO_TLSGD", ",", "\"mips-tlsgd\"", "}", ",", "{", "MO_TLSLDM", ",", "\"mips-tlsldm\"", "}", ",", "{", "MO_DTPREL_HI", ",", "\"mips-dtprel-hi\"", "}", ",", "{", "MO_DTPREL_LO", ",", "\"mips-dtprel-lo\"", "}", ",", "{", "MO_GOTTPREL", ",", "\"mips-gottprel\"", "}", ",", "{", "MO_TPREL_HI", ",", "\"mips-tprel-hi\"", "}", ",", "{", "MO_TPREL_LO", ",", "\"mips-tprel-lo\"", "}", ",", "{", "MO_GPOFF_HI", ",", "\"mips-gpoff-hi\"", "}", ",", "{", "MO_GPOFF_LO", ",", "\"mips-gpoff-lo\"", "}", ",", "{", "MO_GOT_DISP", ",", "\"mips-got-disp\"", "}", ",", "{", "MO_GOT_PAGE", ",", "\"mips-got-page\"", "}", ",", "{", "MO_GOT_OFST", ",", "\"mips-got-ofst\"", "}", ",", "{", "MO_HIGHER", ",", "\"mips-higher\"", "}", ",", "{", "MO_HIGHEST", ",", "\"mips-highest\"", "}", ",", "{", "MO_GOT_HI16", ",", "\"mips-got-hi16\"", "}", ",", "{", "MO_GOT_LO16", ",", "\"mips-got-lo16\"", "}", ",", "{", "MO_CALL_HI16", ",", "\"mips-call-hi16\"", "}", ",", "{", "MO_CALL_LO16", ",", "\"mips-call-lo16\"", "}", ",", "{", "MO_JALR", ",", "\"mips-jalr\"", "}", ",", "{", "MO_PCREL_LO", ",", "\"mips-pcrel-lo16\"", "}", ",", "{", "MO_PCREL_HI", ",", "\"mips-pcrel-hi16\"", "}", ",", "{", "MO_CAPTAB11", ",", "\"mips-captable11\"", "}", ",", "{", "MO_CAPTAB_CALL11", ",", "\"mips-captable11-call\"", "}", ",", "{", "MO_CAPTAB20", ",", "\"mips-captable20\"", "}", ",", "{", "MO_CAPTAB_CALL20", ",", "\"mips-captable20-call\"", "}", ",", "{", "MO_CAPTAB_LO16", ",", "\"mips-captable-lo16\"", "}", ",", "{", "MO_CAPTAB_HI16", ",", "\"mips-captable-hi16\"", "}", ",", "{", "MO_CAPTAB_CALL_LO16", ",", "\"mips-captable-lo16-call\"", "}", ",", "{", "MO_CAPTAB_CALL_HI16", ",", "\"mips-captable-hi16-call\"", "}", ",", "{", "MO_CAPTABLE_OFF_HI", ",", "\"mips-captable-off-hi\"", "}", ",", "{", "MO_CAPTABLE_OFF_LO", ",", "\"mips-captable-off-lo\"", "}", ",", "{", "MO_CAPTAB_TLSGD_HI16", ",", "\"mips-captable-tlsgd-hi16\"", "}", ",", "{", "MO_CAPTAB_TLSGD_LO16", ",", "\"mips-captable-tlsgd-lo16\"", "}", ",", "{", "MO_CAPTAB_TLSLDM_HI16", ",", "\"mips-captable-tlsldm-hi16\"", "}", ",", "{", "MO_CAPTAB_TLSLDM_LO16", ",", "\"mips-captable-tlsldm-lo16\"", "}", ",", "{", "MO_CAPTAB_TPREL_HI16", ",", "\"mips-captable-gottprel-hi16\"", "}", ",", "{", "MO_CAPTAB_TPREL_LO16", ",", "\"mips-captable-gottprel-lo16\"", "}", ",", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "Mips", "Mips", "Mips", "\"mips-got\"", "\"mips-got-call\"", "\"mips-gprel\"", "\"mips-abs-hi\"", "\"mips-abs-lo\"", "\"mips-tlsgd\"", "\"mips-tlsldm\"", "\"mips-dtprel-hi\"", "\"mips-dtprel-lo\"", "\"mips-gottprel\"", "\"mips-tprel-hi\"", "\"mips-tprel-lo\"", "\"mips-gpoff-hi\"", "\"mips-gpoff-lo\"", "\"mips-got-disp\"", "\"mips-got-page\"", "\"mips-got-ofst\"", "\"mips-higher\"", "\"mips-highest\"", "\"mips-got-hi16\"", "\"mips-got-lo16\"", "\"mips-call-hi16\"", "\"mips-call-lo16\"", "\"mips-jalr\"", "\"mips-pcrel-lo16\"", "\"mips-pcrel-hi16\"", "\"mips-captable11\"", "\"mips-captable11-call\"", "\"mips-captable20\"", "\"mips-captable20-call\"", "\"mips-captable-lo16\"", "\"mips-captable-hi16\"", "\"mips-captable-lo16-call\"", "\"mips-captable-hi16-call\"", "\"mips-captable-off-hi\"", "\"mips-captable-off-lo\"", "\"mips-captable-tlsgd-hi16\"", "\"mips-captable-tlsgd-lo16\"", "\"mips-captable-tlsldm-hi16\"", "\"mips-captable-tlsldm-lo16\"", "\"mips-captable-gottprel-hi16\"", "\"mips-captable-gottprel-lo16\"" ]

[]

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

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

[ "SHUXI", "SHUXI", "SHUXI" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "encodeVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "ConstantFP", "*", "Cnt", "=", "MO", ".", "getFPImm", "(", ")", ";", "const", "APFloat", "&", "Val", "=", "Cnt", "->", "getValueAPF", "(", ")", ";", "switch", "(", "Cnt", "->", "getType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported FP type\"", ")", ";", "break", ";", "case", "Type", "::", "FloatTyID", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "NVPTXFloatMCExpr", "::", "createConstantFPSingle", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "case", "Type", "::", "DoubleTyID", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "NVPTXFloatMCExpr", "::", "createConstantFPDouble", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "}", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"unknown operand type\"", "\"Unsupported FP type\"", "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "rtx", "s390_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "arg", ".", "named", ")", "s390_check_type_for_vector_abi", "(", "arg", ".", "type", ",", "true", ",", "false", ")", ";", "if", "(", "s390_function_arg_vector", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "if", "(", "!", "arg", ".", "named", "||", "(", "cum", "->", "vrs", "+", "1", ">", "VEC_ARG_NUM_REG", ")", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", "->", "vrs", "+", "FIRST_VEC_ARG_REGNO", ")", ";", "}", "else", "if", "(", "s390_function_arg_float", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "if", "(", "cum", "->", "fprs", "+", "1", ">", "FP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "else", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", "->", "fprs", "+", "16", ")", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "int", "n_gprs", "=", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ";", "if", "(", "cum", "->", "gprs", "+", "n_gprs", ">", "GP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "else", "if", "(", "n_gprs", "==", "1", "||", "UNITS_PER_WORD", "==", "UNITS_PER_LONG", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", "->", "gprs", "+", "2", ")", ";", "else", "if", "(", "n_gprs", "==", "2", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "cum", "->", "gprs", "+", "2", ")", ",", "const0_rtx", ")", ";", "RTVEC_ELT", "(", "p", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "cum", "->", "gprs", "+", "3", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "arg", ".", "mode", ",", "p", ")", ";", "}", "}", "else", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "const0_rtx", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "S/390", ",", "we", "use", "general", "purpose", "registers", "2", "through", "6", "to", "pass", "integer", ",", "pointer", ",", "and", "certain", "structure", "arguments", ",", "and", "floating", "point", "registers", "0", "and", "2", "(", "0", ",", "2", ",", "4", ",", "and", "6", "on", "64-bit", ")", "to", "pass", "floating", "point", "arguments", ".", "All", "remaining", "arguments", "are", "pushed", "to", "the", "stack", "." ]

[ "s390", "1", "1", "16", "1", "1", "2", "2", "2", "0", "2", "1", "3", "4" ]

[]

[ "<s>", "static", "void", "rs6000_darwin_file_start", "(", "void", ")", "{", "static", "const", "struct", "{", "const", "char", "*", "arg", ";", "const", "char", "*", "name", ";", "HOST_WIDE_INT", "if_set", ";", "}", "mapping", "[", "]", "=", "{", "{", "\"ppc64\"", ",", "\"ppc64\"", ",", "MASK_64BIT", "}", ",", "{", "\"970\"", ",", "\"ppc970\"", ",", "MASK_PPC_GPOPT", "|", "MASK_MFCRF", "|", "MASK_POWERPC64", "}", ",", "{", "\"power4\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"G5\"", ",", "\"ppc970\"", ",", "0", "}", ",", "{", "\"7450\"", ",", "\"ppc7450\"", ",", "0", "}", ",", "{", "\"7400\"", ",", "\"ppc7400\"", ",", "MASK_ALTIVEC", "}", ",", "{", "\"G4\"", ",", "\"ppc7400\"", ",", "0", "}", ",", "{", "\"750\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"740\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"G3\"", ",", "\"ppc750\"", ",", "0", "}", ",", "{", "\"604e\"", ",", "\"ppc604e\"", ",", "0", "}", ",", "{", "\"604\"", ",", "\"ppc604\"", ",", "0", "}", ",", "{", "\"603e\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"603\"", ",", "\"ppc603\"", ",", "0", "}", ",", "{", "\"601\"", ",", "\"ppc601\"", ",", "0", "}", ",", "{", "NULL", ",", "\"ppc\"", ",", "0", "}", "}", ";", "const", "char", "*", "cpu_id", "=", "\"\"", ";", "size_t", "i", ";", "rs6000_file_start", "(", ")", ";", "darwin_file_start", "(", ")", ";", "if", "(", "rs6000_default_cpu", "!=", "0", "&&", "rs6000_default_cpu", "[", "0", "]", "!=", "'\\0'", ")", "cpu_id", "=", "rs6000_default_cpu", ";", "if", "(", "global_options_set", ".", "x_rs6000_cpu_index", ")", "cpu_id", "=", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "name", ";", "i", "=", "0", ";", "while", "(", "mapping", "[", "i", "]", ".", "arg", "!=", "NULL", "&&", "strcmp", "(", "mapping", "[", "i", "]", ".", "arg", ",", "cpu_id", ")", "!=", "0", "&&", "(", "mapping", "[", "i", "]", ".", "if_set", "&", "rs6000_isa_flags", ")", "==", "0", ")", "i", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machine %s\\n\"", ",", "mapping", "[", "i", "]", ".", "name", ")", ";", "}", "</s>" ]

[ "Output", "a", ".machine", "directive", "for", "the", "Darwin", "assembler", ",", "and", "call", "the", "generic", "start_file", "routine", "." ]

[ "powerpcspe", "\"ppc64\"", "\"ppc64\"", "\"970\"", "\"ppc970\"", "\"power4\"", "\"ppc970\"", "0", "\"G5\"", "\"ppc970\"", "0", "\"7450\"", "\"ppc7450\"", "0", "\"7400\"", "\"ppc7400\"", "\"G4\"", "\"ppc7400\"", "0", "\"750\"", "\"ppc750\"", "0", "\"740\"", "\"ppc750\"", "0", "\"G3\"", "\"ppc750\"", "0", "\"604e\"", "\"ppc604e\"", "0", "\"604\"", "\"ppc604\"", "0", "\"603e\"", "\"ppc603\"", "0", "\"603\"", "\"ppc603\"", "0", "\"601\"", "\"ppc601\"", "0", "\"ppc\"", "0", "\"\"", "0", "0", "0", "0", "0", "\"\\t.machine %s\\n\"" ]

[]

[ "<s>", "static", "int", "rs6000_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", ")", "{", "unsigned", "elements", ";", "tree", "elem_type", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "case", "scalar_load", ":", "case", "scalar_store", ":", "case", "vector_stmt", ":", "case", "vector_load", ":", "case", "vector_store", ":", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "case", "cond_branch_not_taken", ":", "return", "1", ";", "case", "vec_perm", ":", "if", "(", "TARGET_VSX", ")", "return", "3", ";", "else", "return", "1", ";", "case", "vec_promote_demote", ":", "if", "(", "TARGET_VSX", ")", "return", "4", ";", "else", "return", "1", ";", "case", "cond_branch_taken", ":", "return", "3", ";", "case", "unaligned_load", ":", "if", "(", "TARGET_VSX", "&&", "TARGET_ALLOW_MOVMISALIGN", ")", "{", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "if", "(", "elements", "==", "2", ")", "return", "2", ";", "if", "(", "elements", "==", "4", ")", "{", "switch", "(", "misalign", ")", "{", "case", "8", ":", "return", "2", ";", "case", "-", "1", ":", "case", "4", ":", "case", "12", ":", "return", "22", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "if", "(", "TARGET_ALTIVEC", ")", "gcc_unreachable", "(", ")", ";", "return", "2", ";", "case", "unaligned_store", ":", "if", "(", "TARGET_VSX", "&&", "TARGET_ALLOW_MOVMISALIGN", ")", "{", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "if", "(", "elements", "==", "2", ")", "return", "2", ";", "if", "(", "elements", "==", "4", ")", "{", "switch", "(", "misalign", ")", "{", "case", "8", ":", "return", "2", ";", "case", "-", "1", ":", "case", "4", ":", "case", "12", ":", "return", "23", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "if", "(", "TARGET_ALTIVEC", ")", "gcc_unreachable", "(", ")", ";", "return", "2", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "elem_type", "=", "TREE_TYPE", "(", "vectype", ")", ";", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "elem_type", ")", "&&", "TYPE_PRECISION", "(", "elem_type", ")", "==", "32", ")", "return", "elements", "+", "1", ";", "else", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

[ "rs6000", "1", "3", "1", "4", "1", "3", "2", "2", "4", "8", "2", "1", "4", "12", "22", "2", "2", "2", "4", "8", "2", "1", "4", "12", "23", "2", "32", "1", "2", "1" ]

[]

[ "<s>", "EVT", "SystemZTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "return", "Subtarget", ".", "hasVector", "(", ")", "?", "MVT", "::", "v2i64", ":", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "SystemZ", "SystemZ", "MVT::v2i64", "MVT::Other" ]

[]

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

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

[ "Videocore" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitJumpTableInfo", "(", ")", "{", "const", "MachineJumpTableInfo", "*", "MJTI", "=", "MF", "->", "getJumpTableInfo", "(", ")", ";", "if", "(", "!", "MJTI", ")", "return", ";", "const", "std", "::", "vector", "<", "MachineJumpTableEntry", ">", "&", "JT", "=", "MJTI", "->", "getJumpTables", "(", ")", ";", "if", "(", "JT", ".", "empty", "(", ")", ")", "return", ";", "const", "TargetLoweringObjectFile", "&", "TLOF", "=", "getObjFileLowering", "(", ")", ";", "MCSection", "*", "ReadOnlySec", "=", "TLOF", ".", "getSectionForJumpTable", "(", "MF", "->", "getFunction", "(", ")", ",", "TM", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ReadOnlySec", ")", ";", "auto", "AFI", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "unsigned", "JTI", "=", "0", ",", "e", "=", "JT", ".", "size", "(", ")", ";", "JTI", "!=", "e", ";", "++", "JTI", ")", "{", "const", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "&", "JTBBs", "=", "JT", "[", "JTI", "]", ".", "MBBs", ";", "if", "(", "JTBBs", ".", "empty", "(", ")", ")", "continue", ";", "unsigned", "Size", "=", "AFI", "->", "getJumpTableEntrySize", "(", "JTI", ")", ";", "emitAlignment", "(", "Align", "(", "Size", ")", ")", ";", "OutStreamer", "->", "emitLabel", "(", "GetJTISymbol", "(", "JTI", ")", ")", ";", "const", "MCSymbol", "*", "BaseSym", "=", "AArch64FI", "->", "getJumpTableEntryPCRelSymbol", "(", "JTI", ")", ";", "const", "MCExpr", "*", "Base", "=", "MCSymbolRefExpr", "::", "create", "(", "BaseSym", ",", "OutContext", ")", ";", "for", "(", "auto", "*", "JTBB", ":", "JTBBs", ")", "{", "const", "MCExpr", "*", "Value", "=", "MCSymbolRefExpr", "::", "create", "(", "JTBB", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ";", "Value", "=", "MCBinaryExpr", "::", "createSub", "(", "Value", ",", "Base", ",", "OutContext", ")", ";", "if", "(", "Size", "!=", "4", ")", "Value", "=", "MCBinaryExpr", "::", "createLShr", "(", "Value", ",", "MCConstantExpr", "::", "create", "(", "2", ",", "OutContext", ")", ",", "OutContext", ")", ";", "OutStreamer", "->", "emitValue", "(", "Value", ",", "Size", ")", ";", "}", "}", "}", "</s>" ]

[ "Print", "assembly", "representations", "of", "the", "jump", "tables", "used", "by", "the", "current", "function", "to", "the", "current", "output", "stream", "." ]

[ "AArch64", "AArch64", "AArch64", "0", "AArch64", "4", "2" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "virtual", "void", "initializePass", "(", ")", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "load_lr_save", "(", "int", "regno", ",", "rtx", "frame_reg_rtx", ",", "int", "offset", ")", "{", "rtx", "mem", "=", "gen_frame_mem_offset", "(", "Pmode", ",", "frame_reg_rtx", ",", "offset", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "}", "</s>" ]

[ "Like", "cr", ",", "the", "move", "to", "lr", "instruction", "can", "be", "scheduled", "after", "the", "stack", "deallocation", ",", "but", "unlike", "cr", ",", "its", "stack", "frame", "save", "is", "still", "valid", ".", "So", "we", "only", "need", "to", "emit", "the", "cfa_restore", "on", "the", "correct", "instruction", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "riscv_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ "riscv" ]

[]