Datasets:

---

docz1105

/

ComBack

like 9

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

[ "This", "is", "just", "a", "placeholder", "to", "make", "linking", "work", "without", "having", "to", "add", "this", "to", "the", "generic", "Darwin", "EXTRA_SECTIONS", ".", "If", "-mcall-aix", "is", "ever", "needed", "for", "Darwin", "(", "not", "too", "likely", "!", ")", "this", "would", "have", "to", "get", "a", "real", "definition", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "alpha_elf_select_rtx_section", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TARGET_SMALL_DATA", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "g_switch_value", ")", "sdata_section", "(", ")", ";", "else", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "Switch", "to", "the", "section", "to", "which", "we", "should", "output", "X", ".", "The", "only", "thing", "special", "we", "do", "here", "is", "to", "honor", "small", "data", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "AVRAsmParser", "::", "ParseDirective", "(", "llvm", "::", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "MachineBasicBlock", "*", "XCoreTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "XCore", "::", "SELECT_CC", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "BRFT_lru6", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "XCore", "XCore", "XCore::SELECT_CC", "\"Unexpected instr type to insert\"", "XCore::BRFT_lru6", "1", "XCore::PHI", "0", "3", "2" ]

[]

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

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

[ "PowerPC", "PPC", "PPC::NOP" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "ARM64", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_arm64_pcrel_adr_imm21\"", ",", "0", ",", "32", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_pcrel_adrp_imm21\"", ",", "0", ",", "32", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_add_imm12\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldst_imm12_scale1\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldst_imm12_scale2\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldst_imm12_scale4\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldst_imm12_scale8\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldst_imm12_scale16\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_arm64_ldr_pcrel_imm19\"", ",", "5", ",", "19", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_movw\"", ",", "5", ",", "16", ",", "0", "}", ",", "{", "\"fixup_arm64_pcrel_branch14\"", ",", "5", ",", "14", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_pcrel_branch19\"", ",", "5", ",", "19", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_pcrel_branch26\"", ",", "0", ",", "26", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_pcrel_call26\"", ",", "0", ",", "26", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_arm64_tlsdesc_call\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "ARM64", "ARM64::NumTargetFixupKinds", "\"fixup_arm64_pcrel_adr_imm21\"", "0", "32", "\"fixup_arm64_pcrel_adrp_imm21\"", "0", "32", "\"fixup_arm64_add_imm12\"", "10", "12", "0", "\"fixup_arm64_ldst_imm12_scale1\"", "10", "12", "0", "\"fixup_arm64_ldst_imm12_scale2\"", "10", "12", "0", "\"fixup_arm64_ldst_imm12_scale4\"", "10", "12", "0", "\"fixup_arm64_ldst_imm12_scale8\"", "10", "12", "0", "\"fixup_arm64_ldst_imm12_scale16\"", "10", "12", "0", "\"fixup_arm64_ldr_pcrel_imm19\"", "5", "19", "\"fixup_arm64_movw\"", "5", "16", "0", "\"fixup_arm64_pcrel_branch14\"", "5", "14", "\"fixup_arm64_pcrel_branch19\"", "5", "19", "\"fixup_arm64_pcrel_branch26\"", "0", "26", "\"fixup_arm64_pcrel_call26\"", "0", "26", "\"fixup_arm64_tlsdesc_call\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "VirtReg", ")", "==", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "Worklist", ";", "SmallSet", "<", "unsigned", ",", "4", ">", "DoneRegs", ";", "Worklist", ".", "push_back", "(", "VirtReg", ")", ";", "while", "(", "Worklist", ".", "size", "(", ")", ")", "{", "unsigned", "Reg", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "if", "(", "!", "DoneRegs", ".", "insert", "(", "Reg", ")", ".", "second", ")", "continue", ";", "for", "(", "auto", "&", "Use", ":", "MRI", "->", "use_instructions", "(", "Reg", ")", ")", "if", "(", "Use", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "LOCRMux", ")", "{", "MachineOperand", "&", "TrueMO", "=", "Use", ".", "getOperand", "(", "1", ")", ";", "MachineOperand", "&", "FalseMO", "=", "Use", ".", "getOperand", "(", "2", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getCommonSubClass", "(", "getRC32", "(", "FalseMO", ",", "VRM", ",", "MRI", ")", ",", "getRC32", "(", "TrueMO", ",", "VRM", ",", "MRI", ")", ")", ";", "if", "(", "RC", "&&", "RC", "!=", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "{", "for", "(", "MCPhysReg", "Reg", ":", "Order", ")", "if", "(", "RC", "->", "contains", "(", "Reg", ")", "&&", "!", "MRI", "->", "isReserved", "(", "Reg", ")", ")", "Hints", ".", "push_back", "(", "Reg", ")", ";", "return", "true", ";", "}", "unsigned", "OtherReg", "=", "(", "TrueMO", ".", "getReg", "(", ")", "==", "Reg", "?", "FalseMO", ".", "getReg", "(", ")", ":", "TrueMO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "OtherReg", ")", "==", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "Worklist", ".", "push_back", "(", "OtherReg", ")", ";", "}", "}", "}", "return", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ",", "Matrix", ")", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "SystemZ", "SystemZ", "SystemZ::GRX32BitRegClass", "8", "4", "SystemZ::LOCRMux", "1", "2", "SystemZ::GRX32BitRegClass", "SystemZ::GRX32BitRegClass" ]

[]

[ "<s>", "static", "unsigned", "long", "thumb1_compute_save_core_reg_mask", "(", "void", ")", "{", "unsigned", "long", "mask", ";", "unsigned", "reg", ";", "mask", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "12", ";", "reg", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "callee_saved_reg_p", "(", "reg", ")", ")", "mask", "|=", "1", "<<", "reg", ";", "if", "(", "frame_pointer_needed", ")", "mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "crtl", "->", "uses_pic_offset_table", ")", "mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "!", "frame_pointer_needed", "&&", "CALLER_INTERWORKING_SLOT_SIZE", ">", "0", ")", "mask", "|=", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "mask", "&", "0xff", "||", "thumb_force_lr_save", "(", ")", ")", "mask", "|=", "(", "1", "<<", "LR_REGNUM", ")", ";", "bool", "call_clobbered_scratch", "=", "(", "thumb1_prologue_unused_call_clobbered_lo_regs", "(", ")", "&&", "thumb1_epilogue_unused_call_clobbered_lo_regs", "(", ")", ")", ";", "if", "(", "(", "mask", "&", "0xff", ")", "==", "0", "&&", "!", "call_clobbered_scratch", "&&", "(", "(", "mask", "&", "0x0f00", ")", "||", "TARGET_BACKTRACE", ")", ")", "{", "reg", "=", "thumb_find_work_register", "(", "1", "<<", "LAST_LO_REGNUM", ")", ";", "if", "(", "reg", "*", "UNITS_PER_WORD", "<=", "(", "unsigned", ")", "arm_size_return_regs", "(", ")", ")", "reg", "=", "LAST_LO_REGNUM", ";", "if", "(", "callee_saved_reg_p", "(", "reg", ")", ")", "mask", "|=", "1", "<<", "reg", ";", "}", "if", "(", "(", "CALLER_INTERWORKING_SLOT_SIZE", "+", "ROUND_UP_WORD", "(", "get_frame_size", "(", ")", ")", "+", "crtl", "->", "outgoing_args_size", ")", ">=", "504", ")", "{", "for", "(", "reg", "=", "LAST_ARG_REGNUM", "+", "1", ";", "reg", "<=", "LAST_LO_REGNUM", ";", "reg", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "reg", ")", ")", "break", ";", "if", "(", "reg", ">", "LAST_LO_REGNUM", ")", "{", "mask", "|=", "1", "<<", "LAST_LO_REGNUM", ";", "}", "}", "return", "mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "core", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", "." ]

[ "arm", "0", "0", "12", "1", "1", "1", "0", "1", "0xff", "1", "0xff", "0", "0x0f00", "1", "1", "504", "1", "1", "1" ]

[]

[ "<s>", "int", "m32c_const_ok_for_constraint_p", "(", "HOST_WIDE_INT", "value", ",", "char", "c", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "str", ")", "{", "if", "(", "memcmp", "(", "str", ",", "\"Is3\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "8", "<=", "value", "&&", "value", "<=", "7", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"IS1\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "128", "<=", "value", "&&", "value", "<=", "127", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"IS2\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "32768", "<=", "value", "&&", "value", "<=", "32767", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"IU2\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "0", "<=", "value", "&&", "value", "<=", "65535", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"IU3\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "0", "<=", "value", "&&", "value", "<=", "0x00ffffff", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"In4\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "8", "<=", "value", "&&", "value", "&&", "value", "<=", "8", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"In5\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "16", "<=", "value", "&&", "value", "&&", "value", "<=", "16", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"IM2\"", ",", "3", ")", "==", "0", ")", "{", "return", "(", "-", "65536", "<=", "value", "&&", "value", "&&", "value", "<=", "-", "1", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"Ilb\"", ",", "3", ")", "==", "0", ")", "{", "int", "b", "=", "exact_log2", "(", "value", ")", ";", "return", "(", "b", ">=", "1", "&&", "b", "<=", "8", ")", ";", "}", "if", "(", "memcmp", "(", "str", ",", "\"Ilw\"", ",", "3", ")", "==", "0", ")", "{", "int", "b", "=", "exact_log2", "(", "value", ")", ";", "return", "(", "b", ">=", "1", "&&", "b", "<=", "16", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implements", "CONST_OK_FOR_CONSTRAINT_P", ".", "Currently", ",", "all", "constant", "constraints", "start", "with", "'", "I", "'", ",", "with", "the", "next", "two", "characters", "indicating", "the", "type", "and", "size", "of", "the", "range", "allowed", "." ]

[ "m32c", "\"Is3\"", "3", "0", "8", "7", "\"IS1\"", "3", "0", "128", "127", "\"IS2\"", "3", "0", "32768", "32767", "\"IU2\"", "3", "0", "0", "65535", "\"IU3\"", "3", "0", "0", "0x00ffffff", "\"In4\"", "3", "0", "8", "8", "\"In5\"", "3", "0", "16", "16", "\"IM2\"", "3", "0", "65536", "1", "\"Ilb\"", "3", "0", "1", "8", "\"Ilw\"", "3", "0", "1", "16", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "isFuncletReturnInstr", "(", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "Func", "->", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CATCHRET", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "ArgInfos", ",", "DL", ",", "MF", ".", "getRegInfo", "(", ")", ")", ";", "Idx", "++", ";", "}", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "0", "1" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DINS", ":", "LowerDins", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DINS", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "!", "Res", ".", "getNode", "(", ")", ")", "return", ";", "if", "(", "N", "->", "getNumValues", "(", ")", "==", "1", ")", "{", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "assert", "(", "(", "N", "->", "getNumValues", "(", ")", "==", "Res", "->", "getNumValues", "(", ")", ")", "&&", "\"Lowering returned the wrong number of results!\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "N", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "RISCV", "RISCV", "0", "1", "\"Lowering returned the wrong number of results!\"", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "MMIX" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "ARMProcClass", "(", "None", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "TSInfo", "(", "*", "TM", ".", "getDataLayout", "(", ")", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "M680x0FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "0", "WebAssembly::BR_IF", "1", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "optimizeLoadInstr", "(", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "unsigned", "&", "FoldAsLoadDefReg", ",", "MachineInstr", "*", "&", "DefMI", ")", "const", "{", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "FoldAsLoadDefReg", ")", ";", "assert", "(", "DefMI", ")", ";", "bool", "SawStore", "=", "false", ";", "if", "(", "!", "DefMI", "->", "isSafeToMove", "(", "nullptr", ",", "SawStore", ")", ")", "return", "nullptr", ";", "SmallVector", "<", "unsigned", ",", "1", ">", "SrcOperandIds", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "FoldAsLoadDefReg", ")", "continue", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "return", "nullptr", ";", "SrcOperandIds", ".", "push_back", "(", "i", ")", ";", "}", "if", "(", "SrcOperandIds", ".", "empty", "(", ")", ")", "return", "nullptr", ";", "if", "(", "MachineInstr", "*", "FoldMI", "=", "foldMemoryOperand", "(", "MI", ",", "SrcOperandIds", ",", "*", "DefMI", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "FoldMI", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "optimizeLoadInstr", "-", "Try", "to", "remove", "the", "load", "by", "folding", "it", "to", "a", "register", "operand", "at", "the", "use", "." ]

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

[]

[ "<s>", "static", "bool", "s390_call_saved_register_used", "(", "tree", "call_expr", ")", "{", "CUMULATIVE_ARGS", "cum_v", ";", "cumulative_args_t", "cum", ";", "tree", "parameter", ";", "machine_mode", "mode", ";", "tree", "type", ";", "rtx", "parm_rtx", ";", "int", "reg", ",", "i", ";", "INIT_CUMULATIVE_ARGS", "(", "cum_v", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "cum", "=", "pack_cumulative_args", "(", "&", "cum_v", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "call_expr_nargs", "(", "call_expr", ")", ";", "i", "++", ")", "{", "parameter", "=", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "type", "=", "TREE_TYPE", "(", "parameter", ")", ";", "gcc_assert", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "gcc_assert", "(", "mode", ")", ";", "if", "(", "pass_by_reference", "(", "&", "cum_v", ",", "mode", ",", "type", ",", "true", ")", ")", "{", "mode", "=", "Pmode", ";", "type", "=", "build_pointer_type", "(", "type", ")", ";", "}", "parm_rtx", "=", "s390_function_arg", "(", "cum", ",", "mode", ",", "type", ",", "true", ")", ";", "s390_function_arg_advance", "(", "cum", ",", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "!", "parm_rtx", ")", "continue", ";", "if", "(", "REG_P", "(", "parm_rtx", ")", ")", "{", "for", "(", "reg", "=", "0", ";", "reg", "<", "REG_NREGS", "(", "parm_rtx", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_regs", "[", "reg", "+", "REGNO", "(", "parm_rtx", ")", "]", ")", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "parm_rtx", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "parm_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "r", "=", "XEXP", "(", "XVECEXP", "(", "parm_rtx", ",", "0", ",", "i", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "r", ")", ")", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "REG_NREGS", "(", "r", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_regs", "[", "reg", "+", "REGNO", "(", "r", ")", "]", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "ARGUMENT_LIST", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

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

[]

[ "<s>", "static", "void", "rl78_note_reg_set", "(", "char", "*", "dead", ",", "rtx", "d", ",", "rtx", "insn", ")", "{", "int", "r", ",", "i", ";", "if", "(", "GET_CODE", "(", "d", ")", "==", "MEM", ")", "rl78_note_reg_uses", "(", "dead", ",", "XEXP", "(", "d", ",", "0", ")", ",", "insn", ")", ";", "if", "(", "GET_CODE", "(", "d", ")", "!=", "REG", ")", "return", ";", "r", "=", "REGNO", "(", "d", ")", ";", "if", "(", "dead", "[", "r", "]", ")", "add_reg_note", "(", "insn", ",", "REG_UNUSED", ",", "gen_rtx_REG", "(", "GET_MODE", "(", "d", ")", ",", "r", ")", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"note set reg %d size %d\\n\"", ",", "r", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "d", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "d", ")", ")", ";", "i", "++", ")", "dead", "[", "r", "+", "i", "]", "=", "1", ";", "}", "</s>" ]

[ "Like", "the", "previous", "function", ",", "but", "scan", "for", "SETs", "instead", "." ]

[ "rl78", "0", "\"note set reg %d size %d\\n\"", "0", "1" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "RISCV" ]

[]

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

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

[ "LC3b", "LC3b", "LC3b", "LC3b" ]

[]

[ "<s>", "bool", "Mips16InstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA16", ":", "ExpandRetRA16", "(", "MBB", ",", "MI", ",", "Mips", "::", "JrcRa16", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ".", "getIterator", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips::RetRA16", "Mips::JrcRa16" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "hasAddr64", "=", "Subtarget", ".", "hasAddr64", "(", ")", ";", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "*", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", "->", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "return", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "DBG_VALUE", "||", "(", "isInt", "<", "16", ">", "(", "Offset", ")", "&&", "(", "!", "usesIXAddr", "(", "*", "MI", ")", "||", "(", "Offset", "&", "3", ")", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"", "PPC::DBG_VALUE", "16", "3", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Op", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Op", "==", "ISD", "::", "SETCC", ")", "return", "false", ";", "return", "TargetLowering", "::", "isTypeDesirableForOp", "(", "Op", ",", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "for", "the", "given", "node", "type", "." ]

[ "AMDGPU", "SI", "MVT::i1", "ISD::SETCC" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDValue", "Callee", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Hexagon", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "RetVal", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "==", "MVT", "::", "i1", ")", "{", "auto", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "FR0", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "unsigned", "PredR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "PredRegsRegClass", ")", ";", "SDValue", "TPR", "=", "DAG", ".", "getCopyToReg", "(", "FR0", ".", "getValue", "(", "1", ")", ",", "dl", ",", "PredR", ",", "FR0", ".", "getValue", "(", "0", ")", ",", "FR0", ".", "getValue", "(", "2", ")", ")", ";", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "TPR", ".", "getValue", "(", "0", ")", ",", "dl", ",", "PredR", ",", "MVT", "::", "i1", ",", "TPR", ".", "getValue", "(", "1", ")", ")", ";", "}", "else", "{", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ";", "}", "InVals", ".", "push_back", "(", "RetVal", ".", "getValue", "(", "0", ")", ")", ";", "Chain", "=", "RetVal", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "RetVal", ".", "getValue", "(", "2", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Hexagon", "Hexagon", "ISD::InputArg", "16", "Hexagon", "0", "MVT::i1", "MVT::i32", "Hexagon::PredRegsRegClass", "1", "0", "2", "0", "MVT::i1", "1", "0", "1", "2" ]

[]

[ "<s>", "void", "GBZ80InstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "if", "(", "Imm", ">=", "0", ")", "O", "<<", "'+'", ";", "O", "<<", "Imm", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"Unknown pcrel immediate operand\"", ")", ";", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "GBZ80", "GB", "0", "\"Unknown pcrel immediate operand\"" ]

[]

[ "<s>", "int", "RISCVFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "RISCV", "::", "X2", ";", "if", "(", "FirstSPAdjustAmount", ")", "Offset", "+=", "FirstSPAdjustAmount", ";", "else", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "if", "(", "hasBP", "(", "MF", ")", ")", "FrameReg", "=", "RISCVABI", "::", "getBPReg", "(", ")", ";", "else", "FrameReg", "=", "RISCV", "::", "X2", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "Offset", "+=", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "FI", ">=", "0", ")", "Offset", "-=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "else", "{", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FI", "<", "0", ")", "Offset", "+=", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "}", "}", "return", "Offset", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "0", "1", "0", "1", "RISCV::X2", "RISCVABI::getBPReg", "RISCV::X2", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "NVPTX" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "X86AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "Type", ";", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "else", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "return", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "1u", "1u", "1u" ]

[]

[ "<s>", "static", "void", "timode_check_non_convertible_regs", "(", "bitmap", "candidates", ",", "bitmap", "regs", ",", "unsigned", "int", "regno", ")", "{", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "regno", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "{", "if", "(", "!", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"r%d has non convertible def in insn %d\\n\"", ",", "regno", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_set_bit", "(", "regs", ",", "regno", ")", ";", "break", ";", "}", "}", "for", "(", "df_ref", "ref", "=", "DF_REG_USE_CHAIN", "(", "regno", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "{", "if", "(", "NONDEBUG_INSN_P", "(", "DF_REF_INSN", "(", "ref", ")", ")", "&&", "!", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"r%d has non convertible use in insn %d\\n\"", ",", "regno", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ";", "bitmap_set_bit", "(", "regs", ",", "regno", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "For", "a", "register", "REGNO", ",", "scan", "instructions", "for", "its", "defs", "and", "uses", ".", "Put", "REGNO", "in", "REGS", "if", "a", "def", "or", "use", "is", "n't", "in", "CANDIDATES", "." ]

[ "i386", "\"r%d has non convertible def in insn %d\\n\"", "\"r%d has non convertible use in insn %d\\n\"" ]

[]

[ "<s>", "bool", "nios2_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "to", "=", "operands", "[", "0", "]", ";", "rtx", "from", "=", "operands", "[", "1", "]", ";", "if", "(", "!", "register_operand", "(", "to", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "from", ",", "mode", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "from", "=", "copy_to_mode_reg", "(", "mode", ",", "from", ")", ";", "}", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "if", "(", "CONST_INT_P", "(", "from", ")", ")", "{", "if", "(", "!", "SMALL_INT", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "SMALL_INT_UNSIGNED", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "UPPER16_INT", "(", "INTVAL", "(", "from", ")", ")", ")", "{", "HOST_WIDE_INT", "high", "=", "(", "INTVAL", "(", "from", ")", "+", "0x8000", ")", "&", "~", "0xffff", ";", "HOST_WIDE_INT", "low", "=", "INTVAL", "(", "from", ")", "&", "0xffff", ";", "emit_move_insn", "(", "to", ",", "gen_int_mode", "(", "high", ",", "SImode", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "to", ",", "gen_int_mode", "(", "low", ",", "HImode", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "from", ")", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "!", "gprel_constant_p", "(", "from", ")", ")", "{", "if", "(", "!", "nios2_large_unspec_reloc_p", "(", "from", ")", ")", "from", "=", "nios2_legitimize_constant_address", "(", "from", ")", ";", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "from", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "to", ",", "from", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "operands", "[", "1", "]", ")", ")", ";", "return", "true", ";", "}", "}", "}", "operands", "[", "0", "]", "=", "to", ";", "operands", "[", "1", "]", "=", "from", ";", "return", "false", ";", "}", "</s>" ]

[ "Main", "expander", "function", "for", "RTL", "moves", "." ]

[ "nios2", "0", "1", "0x8000", "0xffff", "0xffff", "1", "0", "1" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "Hexagon", "::", "IntRegsRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "Hexagon", "::", "DoubleRegsRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDrid", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "Hexagon", "::", "PredRegsRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "assert", "(", "0", "&&", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegisterClass", "Hexagon::LDriw", "0", "Hexagon::DoubleRegsRegisterClass", "Hexagon::LDrid", "0", "Hexagon::PredRegsRegisterClass", "Hexagon::LDriw_pred", "0", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "void", "ix86_check_avx256_stores", "(", "rtx", "dest", ",", "const_rtx", ",", "void", "*", "data", ")", "{", "if", "(", "ix86_check_avx256_register", "(", "dest", ")", ")", "{", "bool", "*", "used", "=", "(", "bool", "*", ")", "data", ";", "*", "used", "=", "true", ";", "}", "}", "</s>" ]

[ "Check", "if", "a", "256bit", "AVX", "register", "is", "referenced", "in", "stores", "." ]

[ "i386" ]

[]

[ "<s>", "void", "s390_expand_split_stack_prologue", "(", "void", ")", "{", "rtx", "r1", ",", "guard", ",", "cc", "=", "NULL", ";", "rtx_insn", "*", "insn", ";", "int", "psso", "=", "TARGET_64BIT", "?", "0x38", ":", "0x20", ";", "HOST_WIDE_INT", "frame_size", "=", "cfun_frame_layout", ".", "frame_size", ";", "HOST_WIDE_INT", "args_size", "=", "crtl", "->", "args", ".", "size", ">=", "0", "?", "(", "(", "crtl", "->", "args", ".", "size", "+", "7", ")", "&", "~", "7", ")", ":", "0", ";", "rtx_code_label", "*", "call_done", "=", "NULL", ";", "rtx_code_label", "*", "parm_base", "=", "NULL", ";", "rtx", "tmp", ";", "gcc_assert", "(", "flag_split_stack", "&&", "reload_completed", ")", ";", "r1", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "if", "(", "!", "frame_size", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "r1", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "STACK_POINTER_OFFSET", ")", ")", ")", ";", "}", "return", ";", "}", "if", "(", "morestack_ref", "==", "NULL_RTX", ")", "{", "morestack_ref", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__morestack\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "morestack_ref", ")", "|=", "(", "SYMBOL_FLAG_LOCAL", "|", "SYMBOL_FLAG_FUNCTION", ")", ";", "}", "if", "(", "CONST_OK_FOR_K", "(", "frame_size", ")", "||", "CONST_OK_FOR_Op", "(", "frame_size", ")", ")", "{", "emit_insn", "(", "gen_get_thread_pointer", "(", "Pmode", ",", "r1", ")", ")", ";", "guard", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "r1", ",", "psso", ")", ")", ";", "if", "(", "frame_size", ">", "SPLIT_STACK_AVAILABLE", ")", "{", "emit_move_insn", "(", "r1", ",", "guard", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_adddi3", "(", "r1", ",", "r1", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "r1", ",", "r1", ",", "GEN_INT", "(", "frame_size", ")", ")", ")", ";", "guard", "=", "r1", ";", "}", "cc", "=", "s390_emit_compare", "(", "LT", ",", "stack_pointer_rtx", ",", "guard", ")", ";", "}", "call_done", "=", "gen_label_rtx", "(", ")", ";", "parm_base", "=", "gen_label_rtx", "(", ")", ";", "LABEL_NUSES", "(", "parm_base", ")", "++", ";", "LABEL_NUSES", "(", "call_done", ")", "++", ";", "insn", "=", "emit_move_insn", "(", "r1", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "parm_base", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "parm_base", ")", ";", "LABEL_NUSES", "(", "parm_base", ")", "++", ";", "if", "(", "cc", "!=", "NULL", ")", "tmp", "=", "gen_split_stack_cond_call", "(", "Pmode", ",", "morestack_ref", ",", "parm_base", ",", "call_done", ",", "GEN_INT", "(", "frame_size", ")", ",", "GEN_INT", "(", "args_size", ")", ",", "cc", ")", ";", "else", "tmp", "=", "gen_split_stack_call", "(", "Pmode", ",", "morestack_ref", ",", "parm_base", ",", "call_done", ",", "GEN_INT", "(", "frame_size", ")", ",", "GEN_INT", "(", "args_size", ")", ")", ";", "insn", "=", "emit_jump_insn", "(", "tmp", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "call_done", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "parm_base", ")", ";", "add_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "call_done", ")", ";", "if", "(", "cc", "!=", "NULL", ")", "{", "add_reg_br_prob_note", "(", "insn", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "r1", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "STACK_POINTER_OFFSET", ")", ")", ")", ";", "}", "}", "else", "{", "emit_barrier", "(", ")", ";", "}", "emit_label", "(", "call_done", ")", ";", "}", "</s>" ]

[ "Emit", "-fsplit-stack", "prologue", ",", "which", "goes", "before", "the", "regular", "function", "prologue", "." ]

[ "s390", "0x38", "0x20", "0", "7", "7", "0", "1", "\"__morestack\"" ]

[]

[ "<s>", "static", "bool", "m32c_function_needs_enter", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "sp", "=", "gen_rtx_REG", "(", "Pmode", ",", "SP_REGNO", ")", ";", "rtx", "fb", "=", "gen_rtx_REG", "(", "Pmode", ",", "FB_REGNO", ")", ";", "for", "(", "insn", "=", "get_topmost_sequence", "(", ")", "->", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "reg_mentioned_p", "(", "sp", ",", "insn", ")", ")", "return", "true", ";", "if", "(", "reg_mentioned_p", "(", "fb", ",", "insn", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "the", "current", "function", "needs", "to", "use", "the", "ENTER/EXIT", "opcodes", ".", "If", "the", "function", "does", "n't", "need", "the", "frame", "base", "or", "stack", "pointer", ",", "it", "can", "use", "the", "simpler", "RTS", "opcode", "." ]

[ "m32c" ]

[]

[ "<s>", "void", "CFGStructurizer", "<", "PassT", ">", "::", "removeSuccessor", "(", "BlockT", "*", "srcBlk", ")", "{", "while", "(", "srcBlk", "->", "succ_size", "(", ")", ")", "{", "srcBlk", "->", "removeSuccessor", "(", "*", "srcBlk", "->", "succ_begin", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Remove", "specified", "successor", "from", "the", "successors", "list", "of", "this", "MachineBasicBlock", "." ]

[ "R600" ]

[]

[ "<s>", "Function", "*", "X86TargetLowering", "::", "getSSPStackGuardCheck", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", "||", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsItaniumEnvironment", "(", ")", ")", "{", "return", "M", ".", "getFunction", "(", "\"__security_check_cookie\"", ")", ";", "}", "return", "TargetLowering", "::", "getSSPStackGuardCheck", "(", "M", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "stack", "protection", "check", "function", "that", "performs", "validation", "and", "error", "handling", ",", "returns", "the", "function", "." ]

[ "X86", "X86", "\"__security_check_cookie\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "mips_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "exp", ")", "==", "CONSTRUCTOR", ")", "return", "MAX", "(", "align", ",", "BITS_PER_WORD", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", "." ]

[ "mips" ]

[]

[ "<s>", "const", "MipsSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "if", "(", "Subtarget", ")", "return", "Subtarget", ";", "return", "&", "DefaultSubtarget", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "MCFragment", "*", "AArch64MCExpr", "::", "findAssociatedFragment", "(", ")", "const", "{", "llvm_unreachable", "(", "\"FIXME: what goes here?\"", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "AArch64", "AArch64", "\"FIXME: what goes here?\"" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "if", "(", "isFrameOperand", "(", "MI", ",", "1", ",", "FrameIndex", ")", ")", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "getMCOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "APFloat", "&", "FloatValue", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "assert", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEsingle", "&&", "\"Only floating point immediates are supported at the moment.\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "FloatValue", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "\"unknown operand type\"", "\"Only floating point immediates are supported at the moment.\"" ]

[]

[ "<s>", "static", "void", "riscv_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.option %spic\\n\"", ",", "(", "flag_pic", "?", "\"\"", ":", "\"no\"", ")", ")", ";", "if", "(", "!", "riscv_mrelax", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option norelax\\n\"", ")", ";", "if", "(", "riscv_mcsr_check", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option csr-check\\n\"", ")", ";", "if", "(", "riscv_emit_attribute_p", ")", "riscv_emit_attribute", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "riscv", "\"\\t.option %spic\\n\"", "\"\"", "\"no\"", "\"\\t.option norelax\\n\"", "\"\\t.option csr-check\\n\"" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "unsigned", "ExtraPredCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_estimated_poly_value", "(", "poly_int64", "val", ")", "{", "enum", "aarch64_sve_vector_bits_enum", "width_source", "=", "aarch64_tune_params", ".", "sve_width", ";", "if", "(", "width_source", "==", "SVE_SCALABLE", ")", "return", "default_estimated_poly_value", "(", "val", ")", ";", "HOST_WIDE_INT", "over_128", "=", "width_source", "-", "128", ";", "return", "val", ".", "coeffs", "[", "0", "]", "+", "val", ".", "coeffs", "[", "1", "]", "*", "over_128", "/", "128", ";", "}", "</s>" ]

[ "Implement", "TARGET_ESTIMATED_POLY_VALUE", ".", "Look", "into", "the", "tuning", "structure", "for", "an", "estimate", ".", "KIND", "specifies", "the", "type", "of", "requested", "estimate", ":", "min", ",", "max", "or", "likely", ".", "For", "cores", "with", "a", "known", "SVE", "width", "all", "three", "estimates", "are", "the", "same", ".", "For", "generic", "SVE", "tuning", "we", "want", "to", "distinguish", "the", "maximum", "estimate", "from", "the", "minimum", "and", "likely", "ones", ".", "The", "likely", "estimate", "is", "the", "same", "as", "the", "minimum", "in", "that", "case", "to", "give", "a", "conservative", "behavior", "of", "auto-vectorizing", "with", "SVE", "when", "it", "is", "a", "win", "even", "for", "128-bit", "SVE", ".", "When", "SVE", "width", "information", "is", "available", "VAL.coeffs", "[", "1", "]", "is", "multiplied", "by", "the", "number", "of", "VQ", "chunks", "over", "the", "initial", "Advanced", "SIMD", "128", "bits", "." ]

[ "aarch64", "128", "0", "1", "128" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "lowerInterleavedStore", "(", "StoreInst", "*", "SI", ",", "ShuffleVectorInst", "*", "SVI", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "VectorType", "*", "VecTy", "=", "SVI", "->", "getType", "(", ")", ";", "assert", "(", "VecTy", "->", "getVectorNumElements", "(", ")", "%", "Factor", "==", "0", "&&", "\"Invalid interleaved store\"", ")", ";", "unsigned", "LaneLen", "=", "VecTy", "->", "getVectorNumElements", "(", ")", "/", "Factor", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "VectorType", "*", "SubVecTy", "=", "VectorType", "::", "get", "(", "EltTy", ",", "LaneLen", ")", ";", "const", "DataLayout", "&", "DL", "=", "SI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "SubVecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "SubVecTy", ")", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "SubVecSize", "!=", "64", "&&", "SubVecSize", "!=", "128", ")", ")", "return", "false", ";", "Value", "*", "Op0", "=", "SVI", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "Op1", "=", "SVI", "->", "getOperand", "(", "1", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "SI", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "{", "Type", "*", "IntTy", "=", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ";", "unsigned", "NumOpElts", "=", "dyn_cast", "<", "VectorType", ">", "(", "Op0", "->", "getType", "(", ")", ")", "->", "getVectorNumElements", "(", ")", ";", "Type", "*", "IntVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "NumOpElts", ")", ";", "Op0", "=", "Builder", ".", "CreatePtrToInt", "(", "Op0", ",", "IntVecTy", ")", ";", "Op1", "=", "Builder", ".", "CreatePtrToInt", "(", "Op1", ",", "IntVecTy", ")", ";", "SubVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "LaneLen", ")", ";", "}", "Type", "*", "PtrTy", "=", "SubVecTy", "->", "getPointerTo", "(", "SI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Type", "*", "Tys", "[", "2", "]", "=", "{", "SubVecTy", ",", "PtrTy", "}", ";", "static", "const", "Intrinsic", "::", "ID", "StoreInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "aarch64_neon_st2", ",", "Intrinsic", "::", "aarch64_neon_st3", ",", "Intrinsic", "::", "aarch64_neon_st4", "}", ";", "Function", "*", "StNFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "SI", "->", "getModule", "(", ")", ",", "StoreInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "SmallVector", "<", "Value", "*", ",", "5", ">", "Ops", ";", "auto", "Mask", "=", "SVI", "->", "getShuffleMask", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Factor", ";", "i", "++", ")", "{", "if", "(", "Mask", "[", "i", "]", ">=", "0", ")", "{", "Ops", ".", "push_back", "(", "Builder", ".", "CreateShuffleVector", "(", "Op0", ",", "Op1", ",", "getSequentialMask", "(", "Builder", ",", "Mask", "[", "i", "]", ",", "LaneLen", ")", ")", ")", ";", "}", "else", "{", "unsigned", "StartMask", "=", "0", ";", "for", "(", "unsigned", "j", "=", "1", ";", "j", "<", "LaneLen", ";", "j", "++", ")", "{", "if", "(", "Mask", "[", "j", "*", "Factor", "+", "i", "]", ">=", "0", ")", "{", "StartMask", "=", "Mask", "[", "j", "*", "Factor", "+", "i", "]", "-", "j", ";", "break", ";", "}", "}", "Ops", ".", "push_back", "(", "Builder", ".", "CreateShuffleVector", "(", "Op0", ",", "Op1", ",", "getSequentialMask", "(", "Builder", ",", "StartMask", ",", "LaneLen", ")", ")", ")", ";", "}", "}", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "SI", "->", "getPointerOperand", "(", ")", ",", "PtrTy", ")", ")", ";", "Builder", ".", "CreateCall", "(", "StNFunc", ",", "Ops", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "2", "\"Invalid interleave factor\"", "0", "\"Invalid interleaved store\"", "64", "128", "0", "1", "2", "Intrinsic::ID", "3", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_st4", "Intrinsic::getDeclaration", "2", "5", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Immed", ")", "const", "{", "return", "(", "(", "Immed", ">>", "12", ")", "==", "0", "||", "(", "(", "Immed", "&", "0xfff", ")", "==", "0", "&&", "Immed", ">>", "24", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "AArch64", "AArch64", "12", "0", "0xfff", "0", "24", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "RISCVRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "switch", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unrecognized ABI\"", ")", ";", "case", "RISCVABI", "::", "ABI_ILP32", ":", "case", "RISCVABI", "::", "ABI_LP64", ":", "return", "CSR_ILP32_LP64_RegMask", ";", "case", "RISCVABI", "::", "ABI_ILP32F", ":", "case", "RISCVABI", "::", "ABI_LP64F", ":", "return", "CSR_ILP32F_LP64F_RegMask", ";", "case", "RISCVABI", "::", "ABI_ILP32D", ":", "case", "RISCVABI", "::", "ABI_LP64D", ":", "return", "CSR_ILP32D_LP64D_RegMask", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"Unrecognized ABI\"", "RISCVABI::ABI_ILP32", "RISCVABI::ABI_LP64", "RISCVABI::ABI_ILP32F", "RISCVABI::ABI_LP64F", "RISCVABI::ABI_ILP32D", "RISCVABI::ABI_LP64D" ]

[]

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

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

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "Type", "*", "MemType", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "SI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "false", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

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

[]

[ "<s>", "static", "bool", "callee_saved_regno_p", "(", "int", "regno", ")", "{", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "switch", "(", "regno", ")", "{", "case", "HARD_FRAME_POINTER_REGNUM", ":", "return", "frame_pointer_needed", ";", "case", "LR_REGNUM", ":", "return", "(", "frame_pointer_needed", "||", "!", "crtl", "->", "is_leaf", "||", "crtl", "->", "uses_pic_offset_table", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", ";", "case", "HW_TO_GCC_REGNO", "(", "25", ")", ":", "case", "HW_TO_GCC_REGNO", "(", "27", ")", ":", "case", "HW_TO_GCC_REGNO", "(", "29", ")", ":", "case", "HW_TO_GCC_REGNO", "(", "31", ")", ":", "return", "crtl", "->", "calls_eh_return", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "REGNO", "must", "be", "saved", "for", "the", "current", "function", "." ]

[ "or1k", "25", "27", "29", "31" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "OR1K", "\"Invalid type access!\"" ]

[]

[ "<s>", "void", "R600RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "llvm_unreachable", "(", "\"Subroutines not supported yet\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"Subroutines not supported yet\"" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.frame\\t$\"", "+", "StringRef", "(", "MipsInstPrinter", "::", "getRegisterName", "(", "stackReg", ")", ")", ".", "lower", "(", ")", "+", "\",\"", "+", "Twine", "(", "stackSize", ")", "+", "\",$\"", "+", "StringRef", "(", "MipsInstPrinter", "::", "getRegisterName", "(", "returnReg", ")", ")", ".", "lower", "(", ")", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips", "\"\\t.frame\\t$\"", "Mips", "\",\"", "\",$\"", "Mips" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_ssemov", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SSEMOV", "||", "mode", "!=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", "gcc_unreachable", "(", ")", ";", "enum", "attr_mode", "insn_mode", "=", "get_attr_mode", "(", "insn", ")", ";", "switch", "(", "insn_mode", ")", "{", "case", "MODE_XI", ":", "case", "MODE_V8DF", ":", "case", "MODE_V16SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "64", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_OI", ":", "case", "MODE_V4DF", ":", "case", "MODE_V8SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "32", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_TI", ":", "case", "MODE_V2DF", ":", "case", "MODE_V4SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "16", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_DI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "HAVE_AS_IX86_INTERUNIT_MOVQ", ")", "return", "\"%vmovq\\t{%1, %q0|%q0, %1}\"", ";", "else", "return", "\"%vmovd\\t{%1, %q0|%q0, %1}\"", ";", "}", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "HAVE_AS_IX86_INTERUNIT_MOVQ", ")", "return", "\"%vmovq\\t{%q1, %0|%0, %q1}\"", ";", "else", "return", "\"%vmovd\\t{%q1, %0|%0, %q1}\"", ";", "}", "else", "return", "\"%vmovq\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_SI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"%vmovd\\t{%1, %k0|%k0, %1}\"", ";", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"%vmovd\\t{%k1, %0|%0, %k1}\"", ";", "else", "return", "\"%vmovd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_HI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vmovw\\t{%1, %k0|%k0, %1}\"", ";", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovw\\t{%k1, %0|%0, %k1}\"", ";", "else", "return", "\"vmovw\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_DF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovsd\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"%vmovsd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_SF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovss\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"%vmovss\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_HF", ":", "case", "MODE_BF", ":", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovsh\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"vmovsh\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_V1DF", ":", "gcc_assert", "(", "!", "TARGET_AVX", ")", ";", "return", "\"movlpd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_V2SF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vmovlps\\t{%1, %d0|%d0, %1}\"", ";", "else", "return", "\"%vmovlps\\t{%1, %0|%0, %1}\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "template", "of", "the", "TYPE_SSEMOV", "instruction", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "i386", "0", "1", "64", "32", "16", "0", "\"%vmovq\\t{%1, %q0|%q0, %1}\"", "\"%vmovd\\t{%1, %q0|%q0, %1}\"", "1", "\"%vmovq\\t{%q1, %0|%0, %q1}\"", "\"%vmovd\\t{%q1, %0|%0, %q1}\"", "\"%vmovq\\t{%1, %0|%0, %1}\"", "0", "\"%vmovd\\t{%1, %k0|%k0, %1}\"", "1", "\"%vmovd\\t{%k1, %0|%0, %k1}\"", "\"%vmovd\\t{%1, %0|%0, %1}\"", "0", "\"vmovw\\t{%1, %k0|%k0, %1}\"", "1", "\"vmovw\\t{%k1, %0|%0, %k1}\"", "\"vmovw\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovsd\\t{%d1, %0|%0, %d1}\"", "\"%vmovsd\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovss\\t{%d1, %0|%0, %d1}\"", "\"%vmovss\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovsh\\t{%d1, %0|%0, %d1}\"", "\"vmovsh\\t{%1, %0|%0, %1}\"", "\"movlpd\\t{%1, %0|%0, %1}\"", "0", "\"vmovlps\\t{%1, %d0|%d0, %1}\"", "\"%vmovlps\\t{%1, %0|%0, %1}\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "SNESRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_Normal_RegMask", ";", "}", "</s>" ]

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

[ "SNES", "SNES" ]

[]

[ "<s>", "void", "ix86_split_fp_absneg_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "absneg_op", ";", "rtx", "dst", ",", "set", ";", "gcc_assert", "(", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "dst", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "0", "]", ")", ";", "if", "(", "code", "==", "ABS", ")", "{", "set", "=", "gen_int_mode", "(", "0x7fffffff", ",", "SImode", ")", ";", "absneg_op", "=", "AND", ";", "}", "else", "{", "set", "=", "gen_int_mode", "(", "0x80000000", ",", "SImode", ")", ";", "absneg_op", "=", "XOR", ";", "}", "set", "=", "gen_rtx_fmt_ee", "(", "absneg_op", ",", "SImode", ",", "dst", ",", "set", ")", ";", "break", ";", "case", "E_DFmode", ":", "if", "(", "TARGET_64BIT", ")", "{", "dst", "=", "gen_lowpart", "(", "DImode", ",", "operands", "[", "0", "]", ")", ";", "dst", "=", "gen_rtx_ZERO_EXTRACT", "(", "DImode", ",", "dst", ",", "const1_rtx", ",", "GEN_INT", "(", "63", ")", ")", ";", "if", "(", "code", "==", "ABS", ")", "set", "=", "const0_rtx", ";", "else", "set", "=", "gen_rtx_NOT", "(", "DImode", ",", "dst", ")", ";", "}", "else", "{", "dst", "=", "gen_highpart", "(", "SImode", ",", "operands", "[", "0", "]", ")", ";", "if", "(", "code", "==", "ABS", ")", "{", "set", "=", "gen_int_mode", "(", "0x7fffffff", ",", "SImode", ")", ";", "absneg_op", "=", "AND", ";", "}", "else", "{", "set", "=", "gen_int_mode", "(", "0x80000000", ",", "SImode", ")", ";", "absneg_op", "=", "XOR", ";", "}", "set", "=", "gen_rtx_fmt_ee", "(", "absneg_op", ",", "SImode", ",", "dst", ",", "set", ")", ";", "}", "break", ";", "case", "E_XFmode", ":", "dst", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "(", "TARGET_64BIT", "?", "1", ":", "2", ")", ")", ";", "if", "(", "code", "==", "ABS", ")", "{", "set", "=", "GEN_INT", "(", "0x7fff", ")", ";", "absneg_op", "=", "AND", ";", "}", "else", "{", "set", "=", "GEN_INT", "(", "0x8000", ")", ";", "absneg_op", "=", "XOR", ";", "}", "set", "=", "gen_rtx_fmt_ee", "(", "absneg_op", ",", "SImode", ",", "dst", ",", "set", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "set", "=", "gen_rtx_SET", "(", "dst", ",", "set", ")", ";", "rtx", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "rtvec", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "clob", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "par", ")", ")", ";", "}", "</s>" ]

[ "Deconstruct", "a", "floating", "point", "ABS", "or", "NEG", "operation", "with", "integer", "registers", "into", "integer", "operations", "." ]

[ "i386", "0", "1", "0", "0x7fffffff", "0x80000000", "0", "63", "0", "0x7fffffff", "0x80000000", "0", "1", "2", "0x7fff", "0x8000", "2" ]

[]

[ "<s>", "bool", "LM32TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "LM32", "LM32" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER" ]

[]

[ "<s>", "void", "TMS320C64XInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "int", "delay", "=", "1", ";", "DebugLoc", "dl", ";", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "TMS320C64X", "::", "noop", ")", ")", ".", "addImm", "(", "delay", ")", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "1", "TMS320C64X::noop" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "materialize", "(", "NodeToValueMap", "&", "Loc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Nodes before materialization:\\n\"", "<<", "Nodes", "<<", "'\\n'", ")", ";", "NodeChildrenMap", "NCM", ";", "NodeVect", "Roots", ";", "invert_find_roots", "(", "Nodes", ",", "NCM", ",", "Roots", ")", ";", "while", "(", "!", "Roots", ".", "empty", "(", ")", ")", "{", "NodeVect", "::", "iterator", "First", "=", "Roots", ".", "begin", "(", ")", ";", "GepNode", "*", "Root", "=", "*", "First", ",", "*", "Last", "=", "*", "First", ";", "Roots", ".", "erase", "(", "First", ")", ";", "NodeVect", "NA", ";", "bool", "LastUsed", "=", "false", ";", "unsigned", "LastCN", "=", "0", ";", "Value", "*", "LocV", "=", "Loc", "[", "Last", "]", ";", "if", "(", "!", "LocV", ")", "continue", ";", "BasicBlock", "*", "LastB", "=", "cast", "<", "BasicBlock", ">", "(", "LocV", ")", ";", "do", "{", "NA", ".", "push_back", "(", "Last", ")", ";", "LastUsed", "=", "(", "Last", "->", "Flags", "&", "GepNode", "::", "Used", ")", ";", "if", "(", "LastUsed", ")", "break", ";", "NodeChildrenMap", "::", "iterator", "CF", "=", "NCM", ".", "find", "(", "Last", ")", ";", "LastCN", "=", "(", "CF", "!=", "NCM", ".", "end", "(", ")", ")", "?", "CF", "->", "second", ".", "size", "(", ")", ":", "0", ";", "if", "(", "LastCN", "!=", "1", ")", "break", ";", "GepNode", "*", "Child", "=", "CF", "->", "second", ".", "front", "(", ")", ";", "BasicBlock", "*", "ChildB", "=", "cast_or_null", "<", "BasicBlock", ">", "(", "Loc", "[", "Child", "]", ")", ";", "if", "(", "ChildB", "!=", "nullptr", "&&", "LastB", "!=", "ChildB", ")", "break", ";", "Last", "=", "Child", ";", "}", "while", "(", "true", ")", ";", "BasicBlock", "::", "iterator", "InsertAt", "=", "LastB", "->", "getTerminator", "(", ")", "->", "getIterator", "(", ")", ";", "if", "(", "LastUsed", "||", "LastCN", ">", "0", ")", "{", "ValueVect", "Urs", ";", "getAllUsersForNode", "(", "Root", ",", "Urs", ",", "NCM", ")", ";", "BasicBlock", "::", "iterator", "FirstUse", "=", "first_use_of_in_block", "(", "Urs", ",", "LastB", ")", ";", "if", "(", "FirstUse", "!=", "LastB", "->", "end", "(", ")", ")", "InsertAt", "=", "FirstUse", ";", "}", "Value", "*", "NewInst", "=", "fabricateGEP", "(", "NA", ",", "InsertAt", ",", "LastB", ")", ";", "if", "(", "LastCN", ">", "0", ")", "{", "NodeVect", "&", "Cs", "=", "NCM", "[", "Last", "]", ";", "for", "(", "GepNode", "*", "CN", ":", "Cs", ")", "{", "CN", "->", "Flags", "&=", "~", "GepNode", "::", "Internal", ";", "CN", "->", "Flags", "|=", "GepNode", "::", "Root", ";", "CN", "->", "BaseVal", "=", "NewInst", ";", "Roots", ".", "push_back", "(", "CN", ")", ";", "}", "}", "if", "(", "LastUsed", ")", "{", "NodeToUsesMap", "::", "iterator", "UF", "=", "Uses", ".", "find", "(", "Last", ")", ";", "assert", "(", "UF", "!=", "Uses", ".", "end", "(", ")", "&&", "\"No use information found\"", ")", ";", "UseSet", "&", "Us", "=", "UF", "->", "second", ";", "for", "(", "Use", "*", "U", ":", "Us", ")", "U", "->", "set", "(", "NewInst", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "method", "can", "be", "implemented", "to", "generate", "a", "mapped", "Value", "on", "demand", "." ]

[ "Hexagon", "Hexagon", "\"Nodes before materialization:\\n\"", "0", "0", "1", "0", "0", "\"No use information found\"" ]

[]

[ "<s>", "static", "void", "pop", "(", "int", "rn", ")", "{", "rtx", "x", ",", "sp_reg", ",", "reg", ";", "if", "(", "rn", "==", "FPUL_REG", ")", "x", "=", "gen_pop_fpul", "(", ")", ";", "else", "if", "(", "rn", "==", "FPSCR_REG", ")", "x", "=", "gen_pop_fpscr", "(", ")", ";", "else", "if", "(", "TARGET_FPU_DOUBLE", "&&", "TARGET_FMOVD", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_OR_XD_REGISTER_P", "(", "rn", ")", ")", "{", "if", "(", "FP_REGISTER_P", "(", "rn", ")", "&&", "(", "rn", "-", "FIRST_FP_REG", ")", "&", "1", ")", "return", ";", "x", "=", "gen_pop_4", "(", "gen_rtx_REG", "(", "DFmode", ",", "rn", ")", ")", ";", "}", "else", "if", "(", "TARGET_SH2E", "&&", "FP_REGISTER_P", "(", "rn", ")", ")", "x", "=", "gen_pop_e", "(", "gen_rtx_REG", "(", "SFmode", ",", "rn", ")", ")", ";", "else", "x", "=", "gen_pop", "(", "gen_rtx_REG", "(", "SImode", ",", "rn", ")", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "reg", "=", "copy_rtx", "(", "GET_CODE", "(", "PATTERN", "(", "x", ")", ")", "==", "PARALLEL", "?", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "x", ")", ",", "0", ",", "0", ")", ")", ":", "SET_DEST", "(", "PATTERN", "(", "x", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "sp_reg", ",", "plus_constant", "(", "SImode", ",", "sp_reg", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

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

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "getDataLayout", "(", ")", ".", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "for", "(", "const", "Function", "*", "Personality", ":", "MMI", "->", "getPersonalities", "(", ")", ")", "{", "if", "(", "Personality", ")", "{", "MCSymbol", "*", "NLPSym", "=", "getSymbolWithGlobalValueBase", "(", "Personality", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "Personality", ")", ",", "true", ")", ";", "}", "}", "}", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", "->", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "else", "OutStreamer", "->", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "PPC", "8", "4" ]

[]

[ "<s>", "static", "void", "pa_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "arg_size", "=", "pa_function_arg_size", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "cum", "->", "nargs_prototype", "--", ";", "cum", "->", "words", "+=", "(", "arg_size", "+", "(", "(", "cum", "->", "words", "&", "01", ")", "&&", "arg", ".", "type", "!=", "NULL_TREE", "&&", "arg_size", ">", "1", ")", ")", ";", "}", "</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", ".", ")" ]

[ "pa", "01", "1" ]

[]

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

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

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "storeRegToStackSlotImpl", "(", "MBB", ",", "MI", ",", "SrcReg", ",", "isKill", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "false", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "sh_is_nott_insn", "(", "const", "rtx_insn", "*", "i", ")", "{", "return", "i", "!=", "NULL", "&&", "GET_CODE", "(", "PATTERN", "(", "i", ")", ")", "==", "SET", "&&", "t_reg_operand", "(", "XEXP", "(", "PATTERN", "(", "i", ")", ",", "0", ")", ",", "VOIDmode", ")", "&&", "negt_reg_operand", "(", "XEXP", "(", "PATTERN", "(", "i", ")", ",", "1", ")", ",", "VOIDmode", ")", ";", "}", "</s>" ]

[ "Given", "an", "insn", ",", "determine", "whether", "it", "'s", "a", "'nott", "'", "insn", ",", "i.e", ".", "an", "insn", "that", "negates", "the", "T", "bit", "and", "stores", "the", "result", "in", "the", "T", "bit", "." ]

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

[]

[ "<s>", "void", "Nios2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "opc", "=", "Subtarget", ".", "hasNios2r2", "(", ")", "?", "Nios2", "::", "ADD_R2", ":", "Nios2", "::", "ADD_R1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Nios2", "::", "ZERO", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2", "Nios2::ADD_R2", "Nios2::ADD_R1", "Nios2::ZERO" ]

[]

[ "<s>", "void", "X86AvoidSFBPass", "::", "buildCopy", "(", "MachineInstr", "*", "LoadInst", ",", "unsigned", "NLoadOpcode", ",", "int64_t", "LoadDisp", ",", "MachineInstr", "*", "StoreInst", ",", "unsigned", "NStoreOpcode", ",", "int64_t", "StoreDisp", ",", "unsigned", "Size", ",", "int64_t", "LMMOffset", ",", "int64_t", "SMMOffset", ")", "{", "MachineOperand", "&", "LoadBase", "=", "getBaseOperand", "(", "LoadInst", ")", ";", "MachineOperand", "&", "StoreBase", "=", "getBaseOperand", "(", "StoreInst", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "LoadInst", "->", "getParent", "(", ")", ";", "MachineMemOperand", "*", "LMMO", "=", "*", "LoadInst", "->", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "SMMO", "=", "*", "StoreInst", "->", "memoperands_begin", "(", ")", ";", "unsigned", "Reg1", "=", "MRI", "->", "createVirtualRegister", "(", "TII", "->", "getRegClass", "(", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "0", ",", "TRI", ",", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "LoadInst", ",", "LoadInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "Reg1", ")", ".", "add", "(", "LoadBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "LoadDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "LMMO", ",", "LMMOffset", ",", "Size", ")", ")", ";", "DEBUG", "(", "LoadInst", "->", "getPrevNode", "(", ")", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "if", "(", "StoreInst", "->", "getPrevNode", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "DEBUG", "(", "StInst", "->", "getPrevNode", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "COPY", "Op", "." ]

[ "X86", "X86", "0", "1", "X86::NoRegister", "X86::NoRegister", "1", "X86::NoRegister", "X86::NoRegister" ]

[]

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

[ "SETUP_FRAME_ADDRESSES", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "addPreEmitPass", "(", ")", "override", "{", "addPass", "(", "createTGSICFGStructurizerPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTGSIPreEmitImmPass", "(", "getTGSITargetMachine", "(", ")", ".", "MCP", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI", "TGSI" ]

[]

[ "<s>", "static", "bool", "avr_decl_absdata_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "return", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "NULL_TREE", "!=", "lookup_attribute", "(", "\"absdata\"", ",", "attributes", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "DECL", "has", "attribute", "`", "absdata", "'", "set", ".", "This", "function", "should", "only", "be", "used", "for", "AVR_TINY", "." ]

[ "avr", "\"absdata\"" ]

[]

[ "<s>", "int", "mt_reg_ok_for_base_p", "(", "rtx", "x", ",", "int", "strict", ")", "{", "if", "(", "strict", ")", "return", "(", "(", "(", "unsigned", ")", "REGNO", "(", "x", ")", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "REG_OK_FOR_BASE_P", "." ]

[ "mt", "1" ]

[]

[ "<s>", "static", "void", "tryAddingPcLoadReferenceComment", "(", "uint64_t", "Address", ",", "int", "Value", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "LLVMSymbolLookupCallback", "SymbolLookUp", "=", "Dis", "->", "getLLVMSymbolLookupCallback", "(", ")", ";", "if", "(", "SymbolLookUp", ")", "{", "void", "*", "DisInfo", "=", "Dis", "->", "getDisInfoBlock", "(", ")", ";", "uint64_t", "ReferenceType", ";", "ReferenceType", "=", "LLVMDisassembler_ReferenceType_In_PCrel_Load", ";", "const", "char", "*", "ReferenceName", ";", "(", "void", ")", "SymbolLookUp", "(", "DisInfo", ",", "Value", ",", "&", "ReferenceType", ",", "Address", ",", "&", "ReferenceName", ")", ";", "if", "(", "ReferenceType", "==", "LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr", "||", "ReferenceType", "==", "LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr", ")", "(", "*", "Dis", "->", "CommentStream", ")", "<<", "\"literal pool for: \"", "<<", "ReferenceName", ";", "}", "}", "</s>" ]

[ "Try", "to", "add", "a", "comment", "on", "the", "PC-relative", "load", "." ]

[ "ARM", "\"literal pool for: \"" ]

[]

[ "<s>", "void", "mips_expand_vec_unpack", "(", "rtx", "operands", "[", "2", "]", ",", "bool", "unsigned_p", ",", "bool", "high_p", ")", "{", "machine_mode", "imode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "(", "*", "unpack", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "cmpFunc", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "tmp", ",", "dest", ",", "zero", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "imode", ")", ")", "{", "switch", "(", "imode", ")", "{", "case", "E_V4SImode", ":", "if", "(", "BYTES_BIG_ENDIAN", "!=", "high_p", ")", "unpack", "=", "gen_msa_ilvl_w", ";", "else", "unpack", "=", "gen_msa_ilvr_w", ";", "cmpFunc", "=", "gen_msa_clt_s_w", ";", "break", ";", "case", "E_V8HImode", ":", "if", "(", "BYTES_BIG_ENDIAN", "!=", "high_p", ")", "unpack", "=", "gen_msa_ilvl_h", ";", "else", "unpack", "=", "gen_msa_ilvr_h", ";", "cmpFunc", "=", "gen_msa_clt_s_h", ";", "break", ";", "case", "E_V16QImode", ":", "if", "(", "BYTES_BIG_ENDIAN", "!=", "high_p", ")", "unpack", "=", "gen_msa_ilvl_b", ";", "else", "unpack", "=", "gen_msa_ilvr_b", ";", "cmpFunc", "=", "gen_msa_clt_s_b", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "if", "(", "!", "unsigned_p", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "cmpFunc", "(", "tmp", ",", "operands", "[", "1", "]", ",", "CONST0_RTX", "(", "imode", ")", ")", ")", ";", "}", "else", "tmp", "=", "force_reg", "(", "imode", ",", "CONST0_RTX", "(", "imode", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "unpack", "(", "dest", ",", "operands", "[", "1", "]", ",", "tmp", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "dest", ")", ")", ";", "return", ";", "}", "switch", "(", "imode", ")", "{", "case", "E_V8QImode", ":", "if", "(", "high_p", ")", "unpack", "=", "gen_loongson_punpckhbh", ";", "else", "unpack", "=", "gen_loongson_punpcklbh", ";", "cmpFunc", "=", "gen_loongson_pcmpgtb", ";", "break", ";", "case", "E_V4HImode", ":", "if", "(", "high_p", ")", "unpack", "=", "gen_loongson_punpckhhw", ";", "else", "unpack", "=", "gen_loongson_punpcklhw", ";", "cmpFunc", "=", "gen_loongson_pcmpgth", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "zero", "=", "force_reg", "(", "imode", ",", "CONST0_RTX", "(", "imode", ")", ")", ";", "if", "(", "unsigned_p", ")", "tmp", "=", "zero", ";", "else", "{", "tmp", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "cmpFunc", "(", "tmp", ",", "zero", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "dest", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "unpack", "(", "dest", ",", "operands", "[", "1", "]", ",", "tmp", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "dest", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "integral", "vector", "unpack", "operation", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", ")", "return", "Match_InvalidOperand", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "AMDGPU", "AMDGPU", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3" ]

[]

[ "<s>", "static", "unsigned", "int", "spu_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "if", "(", "strcmp", "(", "name", ",", "\".toe\"", ")", "==", "0", ")", "return", "SECTION_BSS", ";", "if", "(", "strcmp", "(", "name", ",", "\"._ea\"", ")", "==", "0", ")", "return", "SECTION_WRITE", "|", "SECTION_DEBUG", ";", "return", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "}", "</s>" ]

[ "Implement", "targetm.section_type_flags", "." ]

[ "spu", "\".toe\"", "0", "\"._ea\"", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR432_SPE_SaveList", ";", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_SaveList", ":", "CSR_SVR32_ColdCC_SaveList", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR464_R2_Altivec_SaveList", ":", "CSR_SVR464_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR464_R2_SaveList", ":", "CSR_SVR464_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "def_builtin", "(", "const", "char", "*", "name", ",", "tree", "type", ",", "enum", "rs6000_builtins", "code", ")", "{", "tree", "t", ";", "unsigned", "classify", "=", "rs6000_builtin_info", "[", "(", "int", ")", "code", "]", ".", "attr", ";", "const", "char", "*", "attr_string", "=", "\"\"", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "(", "int", ")", "code", ",", "0", ",", "(", "int", ")", "RS6000_BUILTIN_COUNT", ")", ")", ";", "if", "(", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", ")", "fatal_error", "(", "input_location", ",", "\"internal error: builtin function %s already processed\"", ",", "name", ")", ";", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", "=", "t", "=", "add_builtin_function", "(", "name", ",", "type", ",", "(", "int", ")", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "(", "classify", "&", "RS6000_BTC_CONST", ")", "!=", "0", ")", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", const\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_PURE", ")", "!=", "0", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", pure\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_FP", ")", "!=", "0", ")", "{", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "if", "(", "flag_rounding_math", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, pure\"", ";", "}", "else", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, const\"", ";", "}", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_ATTR_MASK", ")", "!=", "0", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "\"rs6000_builtin, code = %4d, %s%s\\n\"", ",", "(", "int", ")", "code", ",", "name", ",", "attr_string", ")", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

[ "rs6000", "\"\"", "0", "\"internal error: builtin function %s already processed\"", "0", "1", "1", "\", const\"", "0", "1", "1", "\", pure\"", "0", "1", "1", "1", "\", fp, pure\"", "1", "\", fp, const\"", "0", "\"rs6000_builtin, code = %4d, %s%s\\n\"" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "ABI", ".", "IsN64", "(", ")", "&&", "isPositionIndependent", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_GPRel64BlockAddress", ";", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "RV16KDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FrameIndex", ")", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "RV16K", "::", "FRMIDX", ",", "MVT", "::", "i16", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "SDLoc", "(", "Node", ")", ",", "MVT", "::", "i16", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "\"== \"", "\"\\n\"", "1", "ISD::FrameIndex", "MVT::i16", "RV16K::FRMIDX", "MVT::i16", "0", "MVT::i16" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "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", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "BrOffset", ")", ")", "report_fatal_error", "(", "\"Branch offsets outside of the signed 32-bit range not supported\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "auto", "II", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoJump", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_CALL", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "RISCV", "::", "GPRRegClass", ",", "MI", ".", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "return", "8", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "32", "\"Branch offsets outside of the signed 32-bit range not supported\"", "RISCV::GPRRegClass", "RISCV::PseudoJump", "RISCVII::MO_CALL", "RISCV::GPRRegClass", "0", "8" ]

[]

[ "<s>", "Align", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getCPUDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "case", "PPC", "::", "DIR_PWR9", ":", "case", "PPC", "::", "DIR_PWR_FUTURE", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "if", "(", "!", "DisableInnermostLoopAlign32", ")", "{", "if", "(", "ML", "->", "getLoopDepth", "(", ")", ">", "1", "&&", "ML", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "return", "Align", "(", "32", ")", ";", "}", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "Align", "(", "32", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC::DIR_PWR_FUTURE", "1", "32", "PPC", "0", "32", "16", "32", "32" ]

[]

[ "<s>", "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+fp64-denormals,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,\"", ";", "FullFS", "+=", "FS", ";", "if", "(", "GPU", "==", "\"\"", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "GPU", "=", "\"SI\"", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP32Denormals", "=", "false", ";", "FP64Denormals", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "256", "\"+promote-alloca,+fp64-denormals,\"", "\"+flat-for-global,\"", "\"\"", "\"SI\"", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "loongarch_in_small_data_p", "(", "const_tree", "decl", ")", "{", "int", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "VAR_P", "(", "decl", ")", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", ";", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "!=", "0", "&&", "strcmp", "(", "name", ",", "\".sbss\"", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "size", ">", "0", "&&", "size", "<=", "g_switch_value", ";", "}", "</s>" ]

[ "Implement", "TARGET_IN_SMALL_DATA_P", "." ]

[ "loongarch", "0", "\".sdata\"", "0", "\".sbss\"", "0", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "2", "\"Unknown loc info!\"", "ISD::TRUNCATE", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE" ]

[]

[ "<s>", "static", "FRV_INLINE", "int", "frv_regno_ok_for_base_p", "(", "int", "regno", ",", "int", "strict_p", ")", "{", "if", "(", "GPR_P", "(", "regno", ")", ")", "return", "TRUE", ";", "if", "(", "strict_p", ")", "return", "(", "reg_renumber", "[", "regno", "]", ">=", "0", "&&", "GPR_P", "(", "reg_renumber", "[", "regno", "]", ")", ")", ";", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "TRUE", ";", "return", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "register", "is", "ok", "to", "use", "as", "a", "base", "or", "index", "register", "." ]

[ "frv", "0" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "X86RegisterInfo", "*", "X86RI", "=", "TM", "->", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "StackAlignment", "=", "X86RI", "->", "getStackAlignment", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RI", ".", "getNumVirtRegs", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "RI", ".", "getRegClass", "(", "Reg", ")", "->", "getAlignment", "(", ")", ">", "StackAlignment", ")", "{", "FuncInfo", "->", "setReserveFP", "(", "true", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "expand_fusion_p9_load", "(", "rtx", "*", "operands", ")", "{", "rtx", "tmp_reg", "=", "operands", "[", "0", "]", ";", "rtx", "addis_value", "=", "operands", "[", "1", "]", ";", "rtx", "target", "=", "operands", "[", "2", "]", ";", "rtx", "orig_mem", "=", "operands", "[", "3", "]", ";", "rtx", "new_addr", ",", "new_mem", ",", "orig_addr", ",", "offset", ",", "set", ",", "clobber", ",", "insn", ";", "enum", "rtx_code", "plus_or_lo_sum", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "extend_mode", "=", "target_mode", ";", "machine_mode", "ptr_mode", "=", "Pmode", ";", "enum", "rtx_code", "extend", "=", "UNKNOWN", ";", "if", "(", "GET_CODE", "(", "orig_mem", ")", "==", "FLOAT_EXTEND", "||", "GET_CODE", "(", "orig_mem", ")", "==", "ZERO_EXTEND", ")", "{", "extend", "=", "GET_CODE", "(", "orig_mem", ")", ";", "orig_mem", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "target_mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "orig_mem", ")", ")", ";", "orig_addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "plus_or_lo_sum", "=", "GET_CODE", "(", "orig_addr", ")", ";", "gcc_assert", "(", "plus_or_lo_sum", "==", "PLUS", "||", "plus_or_lo_sum", "==", "LO_SUM", ")", ";", "offset", "=", "XEXP", "(", "orig_addr", ",", "1", ")", ";", "new_addr", "=", "gen_rtx_fmt_ee", "(", "plus_or_lo_sum", ",", "ptr_mode", ",", "addis_value", ",", "offset", ")", ";", "new_mem", "=", "replace_equiv_address_nv", "(", "orig_mem", ",", "new_addr", ",", "false", ")", ";", "if", "(", "extend", "!=", "UNKNOWN", ")", "new_mem", "=", "gen_rtx_fmt_e", "(", "extend", ",", "extend_mode", ",", "new_mem", ")", ";", "new_mem", "=", "gen_rtx_UNSPEC", "(", "extend_mode", ",", "gen_rtvec", "(", "1", ",", "new_mem", ")", ",", "UNSPEC_FUSION_P9", ")", ";", "set", "=", "gen_rtx_SET", "(", "target", ",", "new_mem", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "tmp_reg", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", ";", "}", "</s>" ]

[ "During", "the", "peephole2", "pass", ",", "adjust", "and", "expand", "the", "insns", "for", "an", "extended", "fusion", "load", "sequence", ".", "The", "operands", "are", ":", "operands", "[", "0", "]", "register", "set", "with", "addis", "operands", "[", "1", "]", "value", "set", "via", "addis", "operands", "[", "2", "]", "target", "register", "being", "loaded", "operands", "[", "3", "]", "D-form", "memory", "reference", "using", "operands", "[", "0", "]", ".", "This", "is", "similar", "to", "the", "fusion", "introduced", "with", "power8", ",", "except", "it", "scales", "to", "both", "loads/stores", "and", "does", "not", "require", "the", "result", "register", "to", "be", "the", "same", "as", "the", "base", "register", ".", "At", "the", "moment", ",", "we", "only", "do", "this", "if", "register", "set", "with", "addis", "is", "dead", "." ]

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "const", "Function", "&", "F", ",", "Type", "*", "Ty", ")", "const", "{", "switch", "(", "Ty", "->", "getScalarType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "case", "Type", "::", "FloatTyID", ":", "case", "Type", "::", "DoubleTyID", ":", "return", "true", ";", "case", "Type", "::", "FP128TyID", ":", "return", "Subtarget", ".", "hasP9Vector", "(", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "MF", ".", "protectReturnPtr", "(", ")", "&&", "!", "MF", ".", "getName", "(", ")", ".", "equals", "(", "\"main\"", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "if", "(", "MF", ".", "protectFramePtr", "(", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "unsigned", "FPReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", "==", "FPReg", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "bool", "hasGPR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "hasGPR", "=", "true", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "if", "(", "MF", ".", "protectCSRs", "(", ")", "&&", "hasGPR", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "\"main\"", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "static", "int", "eligible_for_restore_insn", "(", "rtx", "trial", ",", "bool", "return_p", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "trial", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "src", ")", ")", "!=", "MODE_FLOAT", "&&", "arith_operand", "(", "src", ",", "GET_MODE", "(", "src", ")", ")", ")", "{", "if", "(", "TARGET_ARCH64", ")", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "src", ")", ")", "<=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "else", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "src", ")", ")", "<=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "src", ")", ")", "!=", "MODE_FLOAT", "&&", "arith_double_operand", "(", "src", ",", "GET_MODE", "(", "src", ")", ")", ")", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "src", ")", ")", "<=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "else", "if", "(", "!", "TARGET_FPU", "&&", "register_operand", "(", "src", ",", "SFmode", ")", ")", "return", "1", ";", "else", "if", "(", "!", "TARGET_FPU", "&&", "TARGET_ARCH64", "&&", "register_operand", "(", "src", ",", "DFmode", ")", ")", "return", "1", ";", "else", "if", "(", "return_p", "&&", "TARGET_V9", "&&", "!", "epilogue_renumber", "(", "&", "pat", ",", "1", ")", "&&", "(", "get_attr_in_uncond_branch_delay", "(", "trial", ")", "==", "IN_UNCOND_BRANCH_DELAY_TRUE", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", "&&", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "SImode", ")", "&&", "arith_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "SImode", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", "&&", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "DImode", ")", "&&", "arith_double_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "DImode", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "LO_SUM", "&&", "!", "TARGET_CM_MEDMID", "&&", "(", "(", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "SImode", ")", "&&", "immediate_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "SImode", ")", ")", "||", "(", "TARGET_ARCH64", "&&", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "DImode", ")", "&&", "immediate_operand", "(", "XEXP", "(", "src", ",", "1", ")", ",", "DImode", ")", ")", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "ASHIFT", "&&", "(", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "SImode", ")", "||", "register_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "DImode", ")", ")", "&&", "XEXP", "(", "src", ",", "1", ")", "==", "const1_rtx", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TRIAL", ",", "an", "insn", ",", "can", "be", "combined", "with", "a", "'restore", "'", "instruction", ".", "RETURN_P", "is", "true", "if", "the", "v9", "variant", "'return", "'", "is", "to", "be", "considered", "in", "the", "test", "too", ".", "TRIAL", "must", "be", "a", "SET", "whose", "destination", "is", "a", "REG", "appropriate", "for", "the", "'restore", "'", "instruction", "or", ",", "if", "RETURN_P", "is", "true", ",", "for", "the", "'return", "'", "instruction", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_hard_regno_call_part_clobbered", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "INT_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_VSX", "&&", "FP_REGNO_P", "(", "regno", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "&&", "!", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", "." ]

[ "rs6000", "4", "8" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "!", "FBB", "&&", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "8", ":", "4", ";", "return", "1", ";", "}", "if", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "Cond", "[", "0", "]", ".", "isReg", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "SI_NON_UNIFORM_BRCOND_PSEUDO", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "Cond", "[", "0", "]", ".", "isImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcode", "(", "static_cast", "<", "BranchPredicate", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "if", "(", "!", "FBB", ")", "{", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "preserveCondRegFlags", "(", "CondBr", "->", "getOperand", "(", "1", ")", ",", "Cond", "[", "1", "]", ")", ";", "fixImplicitOperands", "(", "*", "CondBr", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "8", ":", "4", ";", "return", "1", ";", "}", "assert", "(", "TBB", "&&", "FBB", ")", ";", "MachineInstr", "*", "CondBr", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "fixImplicitOperands", "(", "*", "CondBr", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "MachineOperand", "&", "CondReg", "=", "CondBr", "->", "getOperand", "(", "1", ")", ";", "CondReg", ".", "setIsUndef", "(", "Cond", "[", "1", "]", ".", "isUndef", "(", ")", ")", ";", "CondReg", ".", "setIsKill", "(", "Cond", "[", "1", "]", ".", "isKill", "(", ")", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "ST", ".", "hasOffset3fBug", "(", ")", "?", "16", ":", "8", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_BRANCH", "8", "4", "1", "1", "0", "AMDGPU::SI_NON_UNIFORM_BRCOND_PSEUDO", "0", "1", "0", "0", "1", "1", "1", "8", "4", "1", "AMDGPU::S_BRANCH", "1", "1", "1", "16", "8", "2" ]

[]

[ "<s>", "const", "Z80Subtarget", "*", "Z80TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "true", ";", "if", "(", "SoftFloat", ")", "{", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "}", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "Z80Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "\"target-cpu\"", "\"target-features\"", "512", "\"+soft-float\"", "\",+soft-float\"", "Z80" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_vperm2f128_vblend", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "struct", "expand_vec_perm_d", "dfirst", ",", "dsecond", ";", "unsigned", "i", ",", "j", ",", "msk", ",", "nelt", "=", "d", "->", "nelt", ",", "nelt2", "=", "nelt", "/", "2", ";", "rtx_insn", "*", "seq", ";", "bool", "ok", ";", "rtx", "(", "*", "blend", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "!", "TARGET_AVX", "||", "TARGET_AVX2", "||", "(", "d", "->", "vmode", "!=", "V8SFmode", "&&", "d", "->", "vmode", "!=", "V4DFmode", ")", "||", "!", "d", "->", "one_operand_p", ")", "return", "false", ";", "dfirst", "=", "*", "d", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "dfirst", ".", "perm", "[", "i", "]", "=", "0xff", ";", "for", "(", "i", "=", "0", ",", "msk", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "j", "=", "(", "d", "->", "perm", "[", "i", "]", "&", "nelt2", ")", "?", "i", "|", "nelt2", ":", "i", "&", "~", "nelt2", ";", "if", "(", "dfirst", ".", "perm", "[", "j", "]", "!=", "0xff", "&&", "dfirst", ".", "perm", "[", "j", "]", "!=", "d", "->", "perm", "[", "i", "]", ")", "return", "false", ";", "dfirst", ".", "perm", "[", "j", "]", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "j", "!=", "i", ")", "msk", "|=", "(", "1", "<<", "i", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "if", "(", "dfirst", ".", "perm", "[", "i", "]", "==", "0xff", ")", "dfirst", ".", "perm", "[", "i", "]", "=", "i", ";", "if", "(", "!", "d", "->", "testing_p", ")", "dfirst", ".", "target", "=", "gen_reg_rtx", "(", "dfirst", ".", "vmode", ")", ";", "start_sequence", "(", ")", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "dfirst", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "ok", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "seq", ")", ";", "dsecond", "=", "*", "d", ";", "dsecond", ".", "op0", "=", "dfirst", ".", "target", ";", "dsecond", ".", "op1", "=", "dfirst", ".", "target", ";", "dsecond", ".", "one_operand_p", "=", "true", ";", "dsecond", ".", "target", "=", "gen_reg_rtx", "(", "dsecond", ".", "vmode", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "dsecond", ".", "perm", "[", "i", "]", "=", "i", "^", "nelt2", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "dsecond", ")", ";", "gcc_assert", "(", "ok", ")", ";", "blend", "=", "d", "->", "vmode", "==", "V8SFmode", "?", "gen_avx_blendps256", ":", "gen_avx_blendpd256", ";", "emit_insn", "(", "blend", "(", "d", "->", "target", ",", "dfirst", ".", "target", ",", "dsecond", ".", "target", ",", "GEN_INT", "(", "msk", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_builtin_1", ".", "Try", "to", "implement", "a", "single", "vector", "permutation", "using", "a", "single", "intra-lane", "vector", "permutation", ",", "vperm2f128", "swapping", "the", "lanes", "and", "vblend", "*", "insn", "blending", "the", "non-swapped", "and", "swapped", "vectors", "together", "." ]

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

[]