Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "char", "*", "arm_output_iwmmxt_tinsr", "(", "rtx", "*", "operands", ")", "{", "int", "mask", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "int", "i", ";", "char", "templ", "[", "50", "]", ";", "int", "units", "=", "mode_nunits", "[", "GET_MODE", "(", "operands", "[", "0", "]", ")", "]", ";", "gcc_assert", "(", "(", "mask", "&", "(", "mask", "-", "1", ")", ")", "==", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "++", "i", ")", "{", "if", "(", "(", "mask", "&", "0x01", ")", "==", "1", ")", "{", "break", ";", "}", "mask", ">>=", "1", ";", "}", "gcc_assert", "(", "i", "<", "units", ")", ";", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "E_V8QImode", ":", "sprintf", "(", "templ", ",", "\"tinsrb%%?\\t%%0, %%2, #%d\"", ",", "i", ")", ";", "break", ";", "case", "E_V4HImode", ":", "sprintf", "(", "templ", ",", "\"tinsrh%%?\\t%%0, %%2, #%d\"", ",", "i", ")", ";", "break", ";", "case", "E_V2SImode", ":", "sprintf", "(", "templ", ",", "\"tinsrw%%?\\t%%0, %%2, #%d\"", ",", "i", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "output_asm_insn", "(", "templ", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembly", "for", "a", "WMMX", "tinsr", "instruction", "." ]

[ "arm", "3", "50", "0", "1", "0", "0", "0x01", "1", "1", "0", "\"tinsrb%%?\\t%%0, %%2, #%d\"", "\"tinsrh%%?\\t%%0, %%2, #%d\"", "\"tinsrw%%?\\t%%0, %%2, #%d\"", "\"\"" ]

[]

[ "<s>", "void", "ix86_add_new_builtins", "(", "HOST_WIDE_INT", "isa", ",", "HOST_WIDE_INT", "isa2", ")", "{", "isa", "&=", "~", "OPTION_MASK_ISA_64BIT", ";", "if", "(", "(", "isa", "&", "deferred_isa_values", ")", "==", "0", "&&", "(", "isa2", "&", "deferred_isa_values2", ")", "==", "0", "&&", "(", "(", "deferred_isa_values", "&", "OPTION_MASK_ISA_MMX", ")", "==", "0", "||", "!", "(", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", ")", ")", "return", ";", "deferred_isa_values", "&=", "~", "isa", ";", "deferred_isa_values2", "&=", "~", "isa2", ";", "if", "(", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", "deferred_isa_values", "&=", "~", "OPTION_MASK_ISA_MMX", ";", "int", "i", ";", "tree", "saved_current_target_pragma", "=", "current_target_pragma", ";", "current_target_pragma", "=", "NULL_TREE", ";", "for", "(", "i", "=", "0", ";", "i", "<", "(", "int", ")", "IX86_BUILTIN_MAX", ";", "i", "++", ")", "{", "if", "(", "(", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa", "&", "isa", ")", "!=", "0", "||", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa2", "&", "isa2", ")", "!=", "0", "||", "(", "(", "ix86_builtins_isa", "[", "i", "]", ".", "isa", "&", "OPTION_MASK_ISA_MMX", ")", "!=", "0", "&&", "TARGET_64BIT", "&&", "(", "isa", "&", "OPTION_MASK_ISA_SSE2", ")", "!=", "0", ")", ")", "&&", "ix86_builtins_isa", "[", "i", "]", ".", "set_and_not_built_p", ")", "{", "tree", "decl", ",", "type", ";", "ix86_builtins_isa", "[", "i", "]", ".", "set_and_not_built_p", "=", "false", ";", "type", "=", "ix86_get_builtin_func_type", "(", "ix86_builtins_isa", "[", "i", "]", ".", "tcode", ")", ";", "decl", "=", "add_builtin_function_ext_scope", "(", "ix86_builtins_isa", "[", "i", "]", ".", "name", ",", "type", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "i", "]", "=", "decl", ";", "if", "(", "ix86_builtins_isa", "[", "i", "]", ".", "const_p", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "if", "(", "ix86_builtins_isa", "[", "i", "]", ".", "pure_p", ")", "DECL_PURE_P", "(", "decl", ")", "=", "1", ";", "}", "}", "current_target_pragma", "=", "saved_current_target_pragma", ";", "}", "</s>" ]

[ "Add", "any", "new", "builtin", "functions", "for", "a", "given", "ISA", "that", "may", "not", "have", "been", "declared", ".", "This", "saves", "a", "bit", "of", "space", "compared", "to", "adding", "all", "of", "the", "declarations", "to", "the", "tree", ",", "even", "if", "we", "did", "n't", "use", "them", "." ]

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

[]

[ "<s>", "MCSymbol", "*", "X86MCInstLower", "::", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", "&&", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "return", "AsmPrinter", ".", "getSymbolPreferLocal", "(", "*", "MO", ".", "getGlobal", "(", ")", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "assert", "(", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isMBB", "(", ")", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "MCSymbol", "*", "Sym", "=", "nullptr", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "case", "X86II", "::", "MO_DLLIMPORT", ":", "Name", "+=", "\"__imp_\"", ";", "break", ";", "case", "X86II", "::", "MO_COFFSTUB", ":", "Name", "+=", "\".refptr.\"", ";", "break", ";", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "break", ";", "}", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "AsmPrinter", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "assert", "(", "Suffix", ".", "empty", "(", ")", ")", ";", "Sym", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "}", "Name", "+=", "Suffix", ";", "if", "(", "!", "Sym", ")", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86II", "::", "MO_COFFSTUB", ":", "{", "MachineModuleInfoCOFF", "&", "MMICOFF", "=", "MF", ".", "getMMI", "(", ")", ".", "getObjFileInfo", "<", "MachineModuleInfoCOFF", ">", "(", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMICOFF", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "true", ")", ";", "}", "break", ";", "}", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", ")", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "break", ";", "}", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "X86", "X86", "\"Isn't a symbol reference\"", "128", "X86II::MO_DLLIMPORT", "\"__imp_\"", "X86II::MO_COFFSTUB", "\".refptr.\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"$non_lazy_ptr\"", "X86II::MO_COFFSTUB", "\"Extern symbol not handled yet\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_Token", ":", "O", "<<", "\"Token: \\\"\"", "<<", "getToken", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Register", ":", "O", "<<", "\"Register: \"", "<<", "getReg", "(", ")", ";", "break", ";", "case", "k_Immediate", ":", "O", "<<", "\"Immediate: \\\"\"", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Memri", ":", "{", "O", "<<", "\"Memri: \\\"\"", "<<", "getReg", "(", ")", "<<", "'+'", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "}", "}", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "SNES", "\"Token: \\\"\"", "\"\\\"\"", "\"Register: \"", "\"Immediate: \\\"\"", "\"\\\"\"", "\"Memri: \\\"\"", "\"\\\"\"", "\"\\n\"" ]

[]

[ "<s>", "void", "rs6000_emit_dot_insn", "(", "rtx", "dst", ",", "rtx", "src", ",", "int", "dot", ",", "rtx", "ccreg", ")", "{", "if", "(", "dot", "==", "0", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", ";", "}", "if", "(", "cc_reg_not_cr0_operand", "(", "ccreg", ",", "CCmode", ")", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_move_insn", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "dst", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "rtx", "ccset", "=", "gen_rtx_SET", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ";", "if", "(", "dot", "==", "1", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "dst", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "clobber", ")", ")", ")", ";", "}", "else", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "set", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "potentially", "record-form", "instruction", ",", "setting", "DST", "from", "SRC", ".", "If", "DOT", "is", "0", ",", "that", "is", "all", ";", "otherwise", ",", "set", "CCREG", "to", "the", "result", "of", "the", "signed", "comparison", "of", "DST", "with", "zero", ".", "If", "DOT", "is", "1", ",", "the", "generated", "RTL", "does", "n't", "care", "about", "the", "DST", "result", ";", "if", "DOT", "is", "2", ",", "it", "does", ".", "If", "CCREG", "is", "CR0", "do", "a", "single", "dot", "insn", "(", "as", "a", "PARALLEL", ")", ";", "otherwise", ",", "do", "a", "SET", "and", "a", "separate", "COMPARE", "." ]

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetRegisterInfo", "*", "TRI", "=", "nullptr", ")", "const", "{", "if", "(", "isReg", "(", ")", ")", "{", "OS", "<<", "printReg", "(", "Contents", ".", "R", ".", "Reg", ",", "TRI", ",", "Contents", ".", "R", ".", "Sub", ")", ";", "}", "if", "(", "isImm", "(", ")", ")", "{", "OS", "<<", "Contents", ".", "ImmVal", ";", "}", "}", "</s>" ]

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

[ "RI5CY" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", "=", "0", ",", "unsigned", "Align", "=", "1", ",", "MachineMemOperand", "::", "Flags", "Flags", "=", "MachineMemOperand", "::", "MONone", ",", "bool", "*", "Fast", "=", "nullptr", ")", "const", "{", "if", "(", "Subtarget", ".", "hasPULPExtV2", "(", ")", ")", "{", "if", "(", "Fast", ")", "{", "*", "Fast", "=", "false", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "1" ]

[]

[ "<s>", "bool", "X86CondBrFolding", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "int", "&", "CmpValue", ")", "{", "unsigned", "SrcRegIndex", "=", "0", ";", "unsigned", "ValueIndex", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcRegIndex", "=", "0", ";", "ValueIndex", "=", "1", ";", "break", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcRegIndex", "=", "1", ";", "ValueIndex", "=", "2", ";", "break", ";", "}", "SrcReg", "=", "MI", ".", "getOperand", "(", "SrcRegIndex", ")", ".", "getReg", "(", ")", ";", "assert", "(", "MI", ".", "getOperand", "(", "ValueIndex", ")", ".", "isImm", "(", ")", "&&", "\"Expecting Imm operand\"", ")", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "ValueIndex", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "X86", "X86", "0", "0", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "1", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "2", "\"Expecting Imm operand\"" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FPW", "MSP430::MOV16rr", "MSP430::FPW", "MSP430::SPW", "MSP430::FPW", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

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

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

[ "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "S2_storeri_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrh_io", ":", "case", "Hexagon", "::", "L2_loadruh_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrb_io", ":", "case", "Hexagon", "::", "S2_storerb_io", ":", "case", "Hexagon", "::", "L2_loadrub_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "A2_addi", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopw_io", ":", "case", "Hexagon", "::", "L4_isub_memopw_io", ":", "case", "Hexagon", "::", "L4_add_memopw_io", ":", "case", "Hexagon", "::", "L4_sub_memopw_io", ":", "case", "Hexagon", "::", "L4_and_memopw_io", ":", "case", "Hexagon", "::", "L4_or_memopw_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "L4_iadd_memoph_io", ":", "case", "Hexagon", "::", "L4_isub_memoph_io", ":", "case", "Hexagon", "::", "L4_add_memoph_io", ":", "case", "Hexagon", "::", "L4_sub_memoph_io", ":", "case", "Hexagon", "::", "L4_and_memoph_io", ":", "case", "Hexagon", "::", "L4_or_memoph_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopb_io", ":", "case", "Hexagon", "::", "L4_isub_memopb_io", ":", "case", "Hexagon", "::", "L4_add_memopb_io", ":", "case", "Hexagon", "::", "L4_sub_memopb_io", ":", "case", "Hexagon", "::", "L4_and_memopb_io", ":", "case", "Hexagon", "::", "L4_or_memopb_io", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "J2_loop0i", ":", "return", "isUInt", "<", "10", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "Hexagon::L2_loadri_io", "Hexagon::S2_storeri_io", "Hexagon", "Hexagon", "Hexagon::L2_loadrd_io", "Hexagon::S2_storerd_io", "Hexagon", "Hexagon", "Hexagon::L2_loadrh_io", "Hexagon::L2_loadruh_io", "Hexagon::S2_storerh_io", "Hexagon", "Hexagon", "Hexagon::L2_loadrb_io", "Hexagon::S2_storerb_io", "Hexagon::L2_loadrub_io", "Hexagon", "Hexagon", "Hexagon::A2_addi", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::L4_iadd_memopw_io", "Hexagon::L4_isub_memopw_io", "Hexagon::L4_add_memopw_io", "Hexagon::L4_sub_memopw_io", "Hexagon::L4_and_memopw_io", "Hexagon::L4_or_memopw_io", "0", "255", "Hexagon::L4_iadd_memoph_io", "Hexagon::L4_isub_memoph_io", "Hexagon::L4_add_memoph_io", "Hexagon::L4_sub_memoph_io", "Hexagon::L4_and_memoph_io", "Hexagon::L4_or_memoph_io", "0", "127", "Hexagon::L4_iadd_memopb_io", "Hexagon::L4_isub_memopb_io", "Hexagon::L4_add_memopb_io", "Hexagon::L4_sub_memopb_io", "Hexagon::L4_and_memopb_io", "Hexagon::L4_or_memopb_io", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::J2_loop0i", "10", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "static", "bool", "sched_mem_operand_p", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "switch", "(", "sched_get_opxy_mem_type", "(", "insn", ",", "opx_p", ")", ")", "{", "case", "OP_TYPE_MEM1", ":", "case", "OP_TYPE_MEM6", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", ",", "if", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", "is", "a", "MEM", "." ]

[ "m68k" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExpandGetActiveLaneMask", "(", "EVT", "ResVT", ",", "EVT", "OpVT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasSVE", "(", ")", ")", "return", "true", ";", "if", "(", "ResVT", "!=", "MVT", "::", "nxv2i1", "&&", "ResVT", "!=", "MVT", "::", "nxv4i1", "&&", "ResVT", "!=", "MVT", "::", "nxv8i1", "&&", "ResVT", "!=", "MVT", "::", "nxv16i1", ")", "return", "true", ";", "if", "(", "OpVT", "!=", "MVT", "::", "i32", "&&", "OpVT", "!=", "MVT", "::", "i64", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "@", "llvm.get.active.lane.mask", "intrinsic", "should", "be", "expanded", "using", "generic", "code", "in", "SelectionDAGBuilder", "." ]

[ "AArch64", "AArch64", "MVT::nxv2i1", "MVT::nxv4i1", "MVT::nxv8i1", "MVT::nxv16i1", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "static", "enum", "insn_code", "tilegx_multiply_get_opcode", "(", "const", "struct", "tilegx_multiply_insn_seq_entry", "*", "entry", ")", "{", "return", "tilegx_multiply_insn_seq_decode_opcode", "[", "entry", "->", "compressed_opcode", "]", ";", "}", "</s>" ]

[ "Returns", "the", "insn_code", "in", "ENTRY", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "bool", "Ret", "=", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "processFunctionAfterISel", "(", "MF", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "AArch64", "::", "RET_ReallyLR", ")", ";", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "bool", "Success", "=", "true", ";", "if", "(", "VReg", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "MIRBuilder", ".", "buildExtract", "(", "Reg", ",", "VReg", ",", "Offset", ")", ";", "}", ")", ";", "OutgoingArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "AssignFn", ",", "AssignFn", ")", ";", "Success", "=", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "Success", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AArch64", "AArch64", "AArch64::RET_ReallyLR", "\"Return value without a vreg\"", "AArch64", "AArch64", "8" ]

[]

[ "<s>", "static", "rtx", "nvptx_get_unisimt_predicate", "(", ")", "{", "rtx", "&", "pred", "=", "cfun", "->", "machine", "->", "unisimt_predicate", ";", "return", "pred", "?", "pred", ":", "pred", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "}", "</s>" ]

[ "Return", "a", "BImode", "``", "predicate", "''", "register", "for", "uniform-simt", ",", "similar", "to", "above", "." ]

[ "nvptx" ]

[]

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

[ "isMemUseUpRegs", "-", "Is", "memory", "operand", "use", "up", "regs", ",", "for", "example", ",", "intel", "MS", "inline", "asm", "may", "use", "ARR", "[", "baseReg", "+", "IndexReg", "+", "...", "]", "which", "may", "use", "up", "regs", "in", "[", "...", "]", "expr", ",", "so", "ARR", "[", "baseReg", "+", "IndexReg", "+", "...", "]", "can", "not", "use", "extra", "reg", "for", "ARR", "." ]

[ "X86" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "return", ";", "if", "(", "CurrCycleInstr", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "return", ";", "else", "if", "(", "CurrCycleInstr", "->", "isDebugInstr", "(", ")", ")", "return", ";", "unsigned", "NumWaitStates", "=", "TII", ".", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "AMDGPU", "AMDGPU::IMPLICIT_DEF", "1" ]

[]

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

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "SystemZFrameInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "unsigned", "LowReg", "=", "0", ",", "HighReg", "=", "0", ",", "StartOffset", "=", "-", "1U", ",", "EndOffset", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "FP64RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "CalleeFrameSize", "+=", "8", ";", "if", "(", "StartOffset", ">", "Offset", ")", "{", "LowReg", "=", "Reg", ";", "StartOffset", "=", "Offset", ";", "}", "if", "(", "EndOffset", "<", "Offset", ")", "{", "HighReg", "=", "Reg", ";", "EndOffset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "}", "}", "}", "MFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "MFI", "->", "setLowReg", "(", "LowReg", ")", ";", "MFI", "->", "setHighReg", "(", "HighReg", ")", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "(", "LowReg", "==", "HighReg", "?", "SystemZ", "::", "MOV64mr", ":", "SystemZ", "::", "MOV64mrm", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "0", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Kill", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "!=", "LowReg", "&&", "Reg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64RegClass", ",", "TRI", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "0", "0", "1U", "0", "0", "SystemZ::FP64RegClass", "8", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "0", "0", "0", "SystemZ::FP64RegClass", "SystemZ::FP64RegClass" ]

[]

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

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "Teak" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "nvptx_vector_alignment", "(", "const_tree", "type", ")", "{", "unsigned", "HOST_WIDE_INT", "align", ";", "tree", "size", "=", "TYPE_SIZE", "(", "type", ")", ";", "if", "(", "tree_fits_uhwi_p", "(", "size", ")", ")", "{", "align", "=", "tree_to_uhwi", "(", "size", ")", ";", "align", "=", "MIN", "(", "align", ",", "BIGGEST_ALIGNMENT", ")", ";", "}", "else", "align", "=", "BIGGEST_ALIGNMENT", ";", "align", "=", "MAX", "(", "align", ",", "GET_MODE_ALIGNMENT", "(", "TYPE_MODE", "(", "type", ")", ")", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Limit", "vector", "alignments", "to", "BIGGEST_ALIGNMENT", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Ops", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "sh_option_override", "(", "void", ")", "{", "int", "regno", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "sh_cpu", "=", "PROCESSOR_SH1", ";", "assembler_dialect", "=", "0", ";", "if", "(", "TARGET_SH2", ")", "sh_cpu", "=", "PROCESSOR_SH2", ";", "if", "(", "TARGET_SH2E", ")", "sh_cpu", "=", "PROCESSOR_SH2E", ";", "if", "(", "TARGET_SH2A", ")", "sh_cpu", "=", "PROCESSOR_SH2A", ";", "if", "(", "TARGET_SH3", ")", "sh_cpu", "=", "PROCESSOR_SH3", ";", "if", "(", "TARGET_SH3E", ")", "sh_cpu", "=", "PROCESSOR_SH3E", ";", "if", "(", "TARGET_SH4", ")", "{", "assembler_dialect", "=", "1", ";", "sh_cpu", "=", "PROCESSOR_SH4", ";", "}", "if", "(", "TARGET_SH4A", ")", "{", "assembler_dialect", "=", "1", ";", "sh_cpu", "=", "PROCESSOR_SH4A", ";", "}", "if", "(", "!", "TARGET_SH3", "&&", "TARGET_USERMODE", ")", "TARGET_USERMODE", "=", "false", ";", "if", "(", "!", "strcmp", "(", "sh_div_str", ",", "\"call-div1\"", ")", ")", "sh_div_strategy", "=", "SH_DIV_CALL_DIV1", ";", "else", "if", "(", "!", "strcmp", "(", "sh_div_str", ",", "\"call-fp\"", ")", "&&", "TARGET_FPU_ANY", ")", "sh_div_strategy", "=", "SH_DIV_CALL_FP", ";", "else", "if", "(", "!", "strcmp", "(", "sh_div_str", ",", "\"call-table\"", ")", "&&", "TARGET_DYNSHIFT", ")", "sh_div_strategy", "=", "SH_DIV_CALL_TABLE", ";", "else", "{", "if", "(", "TARGET_HARD_SH4", ")", "sh_div_strategy", "=", "SH_DIV_CALL_TABLE", ";", "else", "if", "(", "TARGET_SH2A", ")", "sh_div_strategy", "=", "SH_DIV_INTRINSIC", ";", "else", "sh_div_strategy", "=", "SH_DIV_CALL_DIV1", ";", "}", "if", "(", "sh_divsi3_libfunc", "[", "0", "]", ")", ";", "else", "if", "(", "TARGET_DIVIDE_CALL_FP", ")", "sh_divsi3_libfunc", "=", "\"__sdivsi3_i4\"", ";", "else", "if", "(", "TARGET_DIVIDE_CALL_TABLE", ")", "sh_divsi3_libfunc", "=", "\"__sdivsi3_i4i\"", ";", "else", "sh_divsi3_libfunc", "=", "\"__sdivsi3\"", ";", "if", "(", "sh_branch_cost", "==", "-", "1", ")", "{", "sh_branch_cost", "=", "2", ";", "}", "if", "(", "!", "global_options_set", ".", "x_TARGET_ZDCBRANCH", "&&", "TARGET_HARD_SH4", ")", "TARGET_ZDCBRANCH", "=", "1", ";", "if", "(", "TARGET_FDPIC", "&&", "!", "flag_pic", ")", "flag_pic", "=", "2", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "!", "VALID_REGISTER_P", "(", "regno", ")", ")", "sh_register_names", "[", "regno", "]", "[", "0", "]", "=", "'\\0'", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "ADDREGNAMES_SIZE", ";", "regno", "++", ")", "if", "(", "!", "VALID_REGISTER_P", "(", "ADDREGNAMES_REGNO", "(", "regno", ")", ")", ")", "sh_additional_register_names", "[", "regno", "]", "[", "0", "]", "=", "'\\0'", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_PREFERGOT", ")", "flag_no_function_cse", "=", "1", ";", "if", "(", "targetm", ".", "small_register_classes_for_mode_p", "(", "VOIDmode", ")", ")", "{", "if", "(", "!", "TARGET_HARD_SH4", "||", "flag_pic", ")", "flag_schedule_insns", "=", "0", ";", "else", "if", "(", "flag_exceptions", ")", "{", "if", "(", "flag_schedule_insns", "&&", "global_options_set", ".", "x_flag_schedule_insns", ")", "warning", "(", "0", ",", "\"ignoring -fschedule-insns because of exception \"", "\"handling bug\"", ")", ";", "flag_schedule_insns", "=", "0", ";", "}", "else", "if", "(", "flag_schedule_insns", "&&", "!", "global_options_set", ".", "x_flag_schedule_insns", ")", "flag_schedule_insns", "=", "0", ";", "}", "if", "(", "(", "flag_unwind_tables", "||", "flag_asynchronous_unwind_tables", "||", "flag_exceptions", "||", "flag_non_call_exceptions", ")", "&&", "flag_omit_frame_pointer", "&&", "!", "TARGET_ACCUMULATE_OUTGOING_ARGS", ")", "{", "warning", "(", "0", ",", "\"unwind tables currently require either a frame pointer \"", "\"or -maccumulate-outgoing-args for correctness\"", ")", ";", "TARGET_ACCUMULATE_OUTGOING_ARGS", "=", "1", ";", "}", "if", "(", "flag_unsafe_math_optimizations", ")", "{", "if", "(", "global_options_set", ".", "x_TARGET_FSCA", "==", "0", "&&", "TARGET_SH4A_FP", ")", "TARGET_FSCA", "=", "1", ";", "if", "(", "global_options_set", ".", "x_TARGET_FSRRA", "==", "0", "&&", "TARGET_SH4A_FP", ")", "TARGET_FSRRA", "=", "1", ";", "}", "TARGET_FSRRA", "=", "TARGET_FSRRA", "&&", "flag_unsafe_math_optimizations", "&&", "flag_finite_math_only", ";", "if", "(", "!", "global_options_set", ".", "x_TARGET_IEEE", ")", "TARGET_IEEE", "=", "!", "flag_finite_math_only", ";", "if", "(", "sh_fixed_range_str", ")", "sh_fix_range", "(", "sh_fixed_range_str", ")", ";", "if", "(", "flag_strict_volatile_bitfields", "<", "0", "&&", "abi_version_at_least", "(", "2", ")", ")", "flag_strict_volatile_bitfields", "=", "1", ";", "sh_override_options_after_change", "(", ")", ";", "selected_atomic_model_", "=", "parse_validate_atomic_model_option", "(", "sh_atomic_model_str", ")", ";", "register_sh_passes", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "macro", ".", "Validate", "and", "override", "various", "options", ",", "and", "do", "some", "machine", "dependent", "initialization", "." ]

[ "sh", "0", "1", "1", "\"call-div1\"", "\"call-fp\"", "\"call-table\"", "0", "\"__sdivsi3_i4\"", "\"__sdivsi3_i4i\"", "\"__sdivsi3\"", "1", "2", "1", "2", "0", "0", "0", "0", "1", "0", "0", "\"ignoring -fschedule-insns because of exception \"", "\"handling bug\"", "0", "0", "0", "\"unwind tables currently require either a frame pointer \"", "\"or -maccumulate-outgoing-args for correctness\"", "1", "0", "1", "0", "1", "0", "2", "1" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STRrs", ":", "case", "ARM", "::", "t2STRs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "VSTRS", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VST1q64", ":", "case", "ARM", "::", "VST1d64TPseudo", ":", "case", "ARM", "::", "VST1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VSTMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARM", "ARM", "ARM::STRrs", "ARM::t2STRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::STRi12", "ARM::t2STRi12", "ARM::tSTRspi", "ARM::VSTRD", "ARM::VSTRS", "1", "2", "2", "0", "1", "0", "ARM::VST1q64", "ARM::VST1d64TPseudo", "ARM::VST1d64QPseudo", "0", "2", "0", "0", "2", "ARM::VSTMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "inline", "tree", "get_svbool_t", "(", "void", ")", "{", "return", "acle_vector_types", "[", "0", "]", "[", "VECTOR_TYPE_svbool_t", "]", ";", "}", "</s>" ]

[ "Return", "the", "ACLE", "type", "svbool_t", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "bool", "need_to_save_reg", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "flag_pic", "&&", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "||", "regno", "==", "TILEGX_PIC_TEXT_LABEL_REGNUM", ")", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "crtl", "->", "saves_all_registers", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "i", ";", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "{", "if", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", "needs", "to", "be", "saved", "in", "the", "stack", "frame", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "numSubRegs", "=", "0", ";", "unsigned", "movOpc", "=", "0", ";", "const", "unsigned", "*", "subRegIdx", "=", "nullptr", ";", "const", "unsigned", "DFP_FP_SubRegsIdx", "[", "]", "=", "{", "SP", "::", "sub_even", ",", "SP", "::", "sub_odd", "}", ";", "const", "unsigned", "QFP_DFP_SubRegsIdx", "[", "]", "=", "{", "SP", "::", "sub_even64", ",", "SP", "::", "sub_odd64", "}", ";", "const", "unsigned", "QFP_FP_SubRegsIdx", "[", "]", "=", "{", "SP", "::", "sub_even", ",", "SP", "::", "sub_odd", ",", "SP", "::", "sub_odd64_then_sub_even", ",", "SP", "::", "sub_odd64_then_sub_odd", "}", ";", "if", "(", "SP", "::", "IntRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "ORrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "SP", "::", "FPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "FMOVS", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "isV9", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "FMOVD", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "subRegIdx", "=", "DFP_FP_SubRegsIdx", ";", "numSubRegs", "=", "2", ";", "movOpc", "=", "SP", "::", "FMOVS", ";", "}", "}", "else", "if", "(", "SP", "::", "QFPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "isV9", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasHardQuad", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "FMOVQ", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "subRegIdx", "=", "QFP_DFP_SubRegsIdx", ";", "numSubRegs", "=", "2", ";", "movOpc", "=", "SP", "::", "FMOVD", ";", "}", "}", "else", "{", "subRegIdx", "=", "QFP_FP_SubRegsIdx", ";", "numSubRegs", "=", "4", ";", "movOpc", "=", "SP", "::", "FMOVS", ";", "}", "}", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "if", "(", "numSubRegs", "==", "0", "||", "subRegIdx", "==", "nullptr", "||", "movOpc", "==", "0", ")", "return", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineInstr", "*", "MovMI", "=", "nullptr", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "numSubRegs", ";", "++", "i", ")", "{", "unsigned", "Dst", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "subRegIdx", "[", "i", "]", ")", ";", "unsigned", "Src", "=", "TRI", "->", "getSubReg", "(", "SrcReg", ",", "subRegIdx", "[", "i", "]", ")", ";", "assert", "(", "Dst", "&&", "Src", "&&", "\"Bad sub-register\"", ")", ";", "MovMI", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "movOpc", ")", ",", "Dst", ")", ".", "addReg", "(", "Src", ")", ";", "}", "MovMI", "->", "addRegisterDefined", "(", "DestReg", ",", "TRI", ")", ";", "if", "(", "KillSrc", ")", "MovMI", "->", "addRegisterKilled", "(", "SrcReg", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "0", "SP::sub_even", "SP::sub_odd", "SP::sub_even64", "SP::sub_odd64", "SP::sub_even", "SP::sub_odd", "SP::sub_odd64_then_sub_even", "SP::sub_odd64_then_sub_odd", "SP::IntRegsRegClass", "SP::ORrr", "SP::G0", "SP::FPRegsRegClass", "SP::FMOVS", "SP::DFPRegsRegClass", "SP::FMOVD", "2", "SP::FMOVS", "SP::QFPRegsRegClass", "SP::FMOVQ", "2", "SP::FMOVD", "4", "SP::FMOVS", "\"Impossible reg-to-reg copy\"", "0", "0", "0", "\"Bad sub-register\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "Thumb2HazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "ITBlockSize", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", "&&", "MI", "!=", "ITBlockMIs", "[", "ITBlockSize", "-", "1", "]", ")", "return", "Hazard", ";", "}", "return", "PostRAHazardRecognizer", "::", "getHazardType", "(", "SU", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "ARM", "1" ]

[]

[ "<s>", "StackOffset", "SIFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SIRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "Ctx", ".", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", "->", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MBlazeFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "MBlaze", "::", "CPURegsRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "MBlaze", "::", "R20", ")", ";", "RegInfo", ".", "addLiveIn", "(", "MBlaze", "::", "R20", ")", ";", "MBlazeFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze::CPURegsRegisterClass", "MBlaze::R20", "MBlaze::R20", "MBlaze" ]

[]

[ "<s>", "int", "SparcSubtarget", "::", "getAdjustedFrameSize", "(", "int", "frameSize", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "{", "frameSize", "+=", "128", ";", "frameSize", "=", "alignTo", "(", "frameSize", ",", "16", ")", ";", "}", "else", "{", "frameSize", "+=", "92", ";", "frameSize", "=", "alignTo", "(", "frameSize", ",", "8", ")", ";", "}", "return", "frameSize", ";", "}", "</s>" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "Sparc", "Sparc", "128", "16", "92", "8" ]

[]

[ "<s>", "static", "tree", "ix86_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "if", "(", "!", "(", "TARGET_80387", "||", "TARGET_FLOAT_RETURNS_IN_80387", ")", ")", "abi", "=", "\"soft\"", ";", "else", "abi", "=", "\"hard\"", ";", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "i386", "\"soft\"", "\"hard\"", "1" ]

[]

[ "<s>", "void", "init", "(", "VLIWMachineScheduler", "*", "dag", ",", "const", "TargetSchedModel", "*", "smodel", ")", "{", "DAG", "=", "dag", ";", "SchedModel", "=", "smodel", ";", "}", "</s>" ]

[ "Initialize", "the", "machine", "model", "for", "instruction", "scheduling", "." ]

[ "Hexagon" ]

[]

[ "<s>", "rtx", "s390_get_thread_pointer", "(", "void", ")", "{", "rtx", "tp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tp", ",", "gen_rtx_REG", "(", "Pmode", ",", "TP_REGNUM", ")", ")", ";", "mark_reg_pointer", "(", "tp", ",", "BITS_PER_WORD", ")", ";", "return", "tp", ";", "}", "</s>" ]

[ "Load", "the", "thread", "pointer", "into", "a", "register", "." ]

[ "s390" ]

[]

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

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass" ]

[]

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

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

[ "rvex", "rvex" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_eh_return_filter_mode", "(", "void", ")", "{", "return", "TARGET_32BIT", "?", "SImode", ":", "word_mode", ";", "}", "</s>" ]

[ "target", "hook", "eh_return_filter_mode" ]

[ "rs6000" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "ARC", "\"ARC DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "bool", "z8k_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "TARGET_STD_RET", "?", "(", "regno", ">=", "4", "&&", "regno", "<=", "7", ")", ":", "regno", "==", "2", ";", "}", "</s>" ]

[ "True", "if", "N", "is", "a", "possible", "register", "number", "for", "a", "function", "value", "as", "seen", "by", "the", "caller", "." ]

[ "z8k", "4", "7", "2" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "riscv_first_stack_step", "(", "struct", "riscv_frame_info", "*", "frame", ")", "{", "HOST_WIDE_INT", "frame_total_constant_size", ";", "if", "(", "!", "frame", "->", "total_size", ".", "is_constant", "(", ")", ")", "frame_total_constant_size", "=", "riscv_stack_align", "(", "frame", "->", "total_size", ".", "coeffs", "[", "0", "]", ")", "-", "riscv_stack_align", "(", "frame", "->", "total_size", ".", "coeffs", "[", "1", "]", ")", ";", "else", "frame_total_constant_size", "=", "frame", "->", "total_size", ".", "to_constant", "(", ")", ";", "if", "(", "SMALL_OPERAND", "(", "frame_total_constant_size", ")", ")", "return", "frame_total_constant_size", ";", "HOST_WIDE_INT", "min_first_step", "=", "RISCV_STACK_ALIGN", "(", "(", "frame", "->", "total_size", "-", "frame", "->", "frame_pointer_offset", ")", ".", "to_constant", "(", ")", ")", ";", "HOST_WIDE_INT", "max_first_step", "=", "IMM_REACH", "/", "2", "-", "PREFERRED_STACK_BOUNDARY", "/", "8", ";", "HOST_WIDE_INT", "min_second_step", "=", "frame_total_constant_size", "-", "max_first_step", ";", "gcc_assert", "(", "min_first_step", "<=", "max_first_step", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "min_second_step", ")", "&&", "frame_total_constant_size", "%", "IMM_REACH", "<", "IMM_REACH", "/", "2", "&&", "frame_total_constant_size", "%", "IMM_REACH", ">=", "min_first_step", ")", "return", "frame_total_constant_size", "%", "IMM_REACH", ";", "if", "(", "TARGET_RVC", ")", "{", "if", "(", "IN_RANGE", "(", "min_second_step", ",", "0", ",", "(", "TARGET_64BIT", "?", "SDSP_REACH", ":", "SWSP_REACH", ")", ")", ")", "return", "MAX", "(", "min_second_step", ",", "min_first_step", ")", ";", "else", "if", "(", "!", "SMALL_OPERAND", "(", "min_second_step", ")", ")", "return", "min_first_step", ";", "}", "return", "max_first_step", ";", "}", "</s>" ]

[ "For", "stack", "frames", "that", "ca", "n't", "be", "allocated", "with", "a", "single", "ADDI", "instruction", ",", "compute", "the", "best", "value", "to", "initially", "allocate", ".", "It", "must", "at", "a", "minimum", "allocate", "enough", "space", "to", "spill", "the", "callee-saved", "registers", "." ]

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

[]

[ "<s>", "bool", "mips_expand_ext_as_unaligned_load", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "width", ",", "HOST_WIDE_INT", "bitpos", ",", "bool", "unsigned_p", ")", "{", "rtx", "left", ",", "right", ",", "temp", ";", "rtx", "dest1", "=", "NULL_RTX", ";", "if", "(", "GET_MODE", "(", "dest", ")", "==", "DImode", "&&", "(", "REG_P", "(", "dest", ")", "||", "(", "SUBREG_P", "(", "dest", ")", "&&", "!", "MEM_P", "(", "SUBREG_REG", "(", "dest", ")", ")", ")", ")", "&&", "GET_MODE_BITSIZE", "(", "SImode", ")", "==", "width", ")", "{", "dest1", "=", "dest", ";", "dest", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "}", "if", "(", "!", "mips_get_unaligned_mem", "(", "src", ",", "width", ",", "bitpos", ",", "&", "left", ",", "&", "right", ")", ")", "return", "false", ";", "temp", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "dest", ")", ")", ";", "if", "(", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", "{", "emit_insn", "(", "gen_mov_ldl", "(", "temp", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_ldr", "(", "dest", ",", "copy_rtx", "(", "src", ")", ",", "right", ",", "temp", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_mov_lwl", "(", "temp", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_lwr", "(", "dest", ",", "copy_rtx", "(", "src", ")", ",", "right", ",", "temp", ")", ")", ";", "}", "if", "(", "dest1", ")", "{", "if", "(", "unsigned_p", ")", "emit_insn", "(", "gen_zero_extendsidi2", "(", "dest1", ",", "dest", ")", ")", ";", "else", "emit_insn", "(", "gen_extendsidi2", "(", "dest1", ",", "dest", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "use", "left/right", "loads", "to", "expand", "an", "``", "extv", "''", "or", "``", "extzv", "''", "pattern", ".", "DEST", ",", "SRC", ",", "WIDTH", "and", "BITPOS", "are", "the", "operands", "passed", "to", "the", "expander", ";", "the", "operation", "is", "the", "equivalent", "of", ":", "(", "set", "DEST", "(", "*", "_extract", "SRC", "WIDTH", "BITPOS", ")", ")", "Return", "true", "on", "success", "." ]

[ "mips" ]

[]

[ "<s>", "static", "unsigned", "riscv_pass_mode_in_fpr_p", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "UNITS_PER_FP_ARG", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "return", "2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "If", "MODE", "represents", "an", "argument", "that", "can", "be", "passed", "or", "returned", "in", "floating-point", "registers", ",", "return", "the", "number", "of", "registers", ",", "else", "0", "." ]

[ "riscv", "1", "2", "0" ]

[]

[ "<s>", "bool", "insertEdge", "(", "Register", "Reg", ")", "{", "return", "Edges", ".", "insert", "(", "Reg", ")", ".", "second", ";", "}", "</s>" ]

[ "Update", "the", "call", "graph", "after", "inserting", "a", "new", "edge", "." ]

[ "X86" ]

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMappings", "AArch64RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "getSizeInBits", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "TRI", ")", ";", "if", "(", "Size", "!=", "32", "&&", "Size", "!=", "64", ")", "break", ";", "if", "(", "MI", ".", "getNumOperands", "(", ")", "!=", "3", ")", "break", ";", "InstructionMappings", "AltMappings", ";", "InstructionMapping", "GPRMapping", "(", "1", ",", "1", ",", "3", ")", ";", "InstructionMapping", "FPRMapping", "(", "2", ",", "1", ",", "3", ")", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "!=", "3", ";", "++", "Idx", ")", "{", "GPRMapping", ".", "setOperandMapping", "(", "Idx", ",", "Size", ",", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ")", ";", "FPRMapping", ".", "setOperandMapping", "(", "Idx", ",", "Size", ",", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ")", ";", "}", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "GPRMapping", ")", ")", ";", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "FPRMapping", ")", ")", ";", "return", "AltMappings", ";", "}", "default", ":", "break", ";", "}", "return", "RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "MI", ")", ";", "}", "</s>" ]

[ "Get", "the", "alternative", "mappings", "for", "MI", "." ]

[ "AArch64", "AArch64", "0", "32", "64", "3", "1", "1", "3", "2", "1", "3", "0", "3", "AArch64::GPRRegBankID", "AArch64::FPRRegBankID" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_value", "(", "const_tree", "type", ",", "const_tree", "ARG_UNUSED", "(", "func", ")", ",", "bool", "outgoing", ")", "{", "machine_mode", "mode", "=", "promote_return", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "if", "(", "outgoing", ")", "{", "gcc_assert", "(", "cfun", ")", ";", "cfun", "->", "machine", "->", "return_mode", "=", "mode", ";", "return", "gen_rtx_REG", "(", "mode", ",", "NVPTX_RETURN_REGNUM", ")", ";", "}", "return", "nvptx_libcall_value", "(", "mode", ",", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "TARGET_FUNCTION_VALUE", "implementation", ".", "Returns", "an", "RTX", "representing", "the", "place", "where", "function", "FUNC", "returns", "or", "receives", "a", "value", "of", "data", "type", "TYPE", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass2", "(", ")", "{", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "TM", "->", "getMCAsmInfo", "(", ")", ";", "addPass", "(", "createX86SpeculativeExecutionSideEffectSuppression", "(", ")", ")", ";", "addPass", "(", "createX86IndirectThunksPass", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "addPass", "(", "createX86AvoidTrailingCallPass", "(", ")", ")", ";", "if", "(", "!", "TT", ".", "isOSDarwin", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "DwarfCFI", ")", ")", "addPass", "(", "createCFIInstrInserter", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "addPass", "(", "createX86LoadValueInjectionRetHardeningPass", "(", ")", ")", ";", "addPass", "(", "createPseudoProbeInserter", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSDarwin", "(", ")", ")", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "Module", "*", "M", "=", "F", ".", "getParent", "(", ")", ";", "return", "M", "->", "getFunction", "(", "\"objc_retainAutoreleasedReturnValue\"", ")", "||", "M", "->", "getFunction", "(", "\"objc_unsafeClaimAutoreleasedReturnValue\"", ")", ";", "}", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "\"objc_retainAutoreleasedReturnValue\"", "\"objc_unsafeClaimAutoreleasedReturnValue\"" ]

[]

[ "<s>", "bool", "SPIRVPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "SPIRV", "SPIRV" ]

[]

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

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "EX", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "static", "bool", "s390_expand_vec_compare_scalar", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "cmp1", ",", "rtx", "cmp2", ",", "rtx", "*", "cc", ")", "{", "machine_mode", "cmp_mode", ";", "bool", "swap_p", "=", "false", ";", "switch", "(", "*", "code", ")", "{", "case", "EQ", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "NE", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "GT", ":", "cmp_mode", "=", "CCVFHmode", ";", "break", ";", "case", "GE", ":", "cmp_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "UNLE", ":", "cmp_mode", "=", "CCVFHmode", ";", "break", ";", "case", "UNLT", ":", "cmp_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "LT", ":", "cmp_mode", "=", "CCVFHmode", ";", "*", "code", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cmp_mode", "=", "CCVFHEmode", ";", "*", "code", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNGE", ":", "cmp_mode", "=", "CCVFHmode", ";", "*", "code", "=", "UNLE", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNGT", ":", "cmp_mode", "=", "CCVFHEmode", ";", "*", "code", "=", "UNLT", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "swap_p", ")", "{", "rtx", "tmp", "=", "cmp2", ";", "cmp2", "=", "cmp1", ";", "cmp1", "=", "tmp", ";", "}", "*", "cc", "=", "gen_rtx_REG", "(", "cmp_mode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "*", "cc", ",", "gen_rtx_COMPARE", "(", "cmp_mode", ",", "cmp1", ",", "cmp2", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "V2DImode", ")", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Helper", "function", "for", "s390_emit_compare", ".", "If", "possible", "emit", "a", "64", "bit", "FP", "compare", "using", "the", "single", "element", "variant", "of", "vector", "instructions", ".", "Replace", "CODE", "with", "the", "comparison", "code", "to", "be", "used", "in", "the", "CC", "reg", "compare", "and", "return", "the", "condition", "code", "register", "RTX", "in", "CC", "." ]

[ "s390", "2" ]

[]

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

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

[ "Xtensa", "Xtensa", "Xtensa" ]

[]

[ "<s>", "static", "bool", "tilegx_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "return", "true", ";", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "tilegx" ]

[]

[ "<s>", "BitVector", "SystemZRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11W", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R10Q", ")", ";", "}", "Reserved", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15W", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14Q", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::R11D", "SystemZ::R11W", "SystemZ::R10Q", "SystemZ::R15D", "SystemZ::R15W", "SystemZ::R14Q" ]

[]

[ "<s>", "static", "void", "ft32_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "named_size", "=", "0", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "named_size", "=", "GET_MODE_SIZE", "(", "SImode", ")", "*", "(", "*", "cum", "-", "FT32_R0", ")", "+", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "if", "(", "named_size", "<", "24", ")", "*", "pretend_size", "=", "24", "-", "named_size", ";", "else", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "SNESAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "ExpectedKind", ")", "{", "SNESOperand", "&", "Op", "=", "static_cast", "<", "SNESOperand", "&", ">", "(", "AsmOp", ")", ";", "MatchClassKind", "Expected", "=", "static_cast", "<", "MatchClassKind", ">", "(", "ExpectedKind", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "MCConstantExpr", "const", "*", "Const", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "{", "int64_t", "RegNum", "=", "Const", "->", "getValue", "(", ")", ";", "std", "::", "ostringstream", "RegName", ";", "RegName", "<<", "\"r\"", "<<", "RegNum", ";", "RegNum", "=", "MatchRegisterName", "(", "RegName", ".", "str", "(", ")", ".", "c_str", "(", ")", ")", ";", "if", "(", "RegNum", "!=", "SNES", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "RegNum", ")", ";", "if", "(", "validateOperandClass", "(", "Op", ",", "Expected", ")", "==", "Match_Success", ")", "{", "return", "Match_Success", ";", "}", "}", "}", "}", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "isSubclass", "(", "Expected", ",", "MCK_MainRegs", ")", ")", "{", "unsigned", "correspondingDREG", "=", "toDREG", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "correspondingDREG", "!=", "SNES", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "correspondingDREG", ")", ";", "return", "validateOperandClass", "(", "Op", ",", "Expected", ")", ";", "}", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES", "SNES", "\"r\"", "SNES::NoRegister", "SNES::NoRegister" ]

[]

[ "<s>", "static", "bool", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>" ]

[ "Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "FUNCTION_ARG_REGNO_P", "(", "first_anon_arg", ")", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "arc", "0" ]

[]

[ "<s>", "static", "void", "visium_add_cfa_restore_note", "(", "rtx", "reg", ")", "{", "cfa_restores", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "cfa_restores", ")", ";", "}", "</s>" ]

[ "Queue", "a", "REG_CFA_RESTORE", "note", "until", "next", "stack", "manipulation", "insn", "." ]

[ "visium" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ",", "MaybeAlign", "EncodingAlignment", ")", "const", "{", "if", "(", "SelectAddressPCRel", "(", "N", ",", "Base", ")", ")", "return", "false", ";", "int16_t", "Imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "hasSPE", "(", ")", "&&", "SelectAddressEVXRegReg", "(", "N", ",", "Base", ",", "Index", ",", "DAG", ")", ")", "return", "true", ";", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "Imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "isAligned", "(", "*", "EncodingAlignment", ",", "Imm", ")", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "Imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "isAligned", "(", "*", "EncodingAlignment", ",", "Imm", ")", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ")", ";", "if", "(", "LHSKnown", ".", "Zero", ".", "getBoolValue", "(", ")", ")", "{", "KnownBits", "RHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "1", ")", ")", ";", "if", "(", "~", "(", "LHSKnown", ".", "Zero", "|", "RHSKnown", ".", "Zero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "DebugLoc", "&", "dl", ",", "const", "ThumbRegisterInfo", "&", "MRI", ",", "int", "NumBytes", ",", "unsigned", "MIFlags", "=", "MachineInstr", "::", "NoFlags", ")", "{", "emitThumbRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "ARM", "::", "SP", ",", "NumBytes", ",", "TII", ",", "MRI", ",", "MIFlags", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

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

[]

[ "<s>", "BitVector", "TGSIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "rsv", "(", "getNumRegs", "(", ")", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "TEMP0x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "TEMP0y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "TEMP0z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "TEMP0w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "TEMP0", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV0x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV0y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV0z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV0w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV0", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV1x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV1y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV1z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV1w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV1", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV2x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV2y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV2z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV2w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV2", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV3x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV3y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV3z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV3w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV3", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV4x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV4y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV4z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV4w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "SV4", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "ADDR0x", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "ADDR0y", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "ADDR0z", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "ADDR0w", ")", ";", "rsv", ".", "set", "(", "TGSI", "::", "ADDR0", ")", ";", "return", "rsv", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI::TEMP0x", "TGSI::TEMP0y", "TGSI::TEMP0z", "TGSI::TEMP0w", "TGSI::TEMP0", "TGSI::SV0x", "TGSI::SV0y", "TGSI::SV0z", "TGSI::SV0w", "TGSI::SV0", "TGSI::SV1x", "TGSI::SV1y", "TGSI::SV1z", "TGSI::SV1w", "TGSI::SV1", "TGSI::SV2x", "TGSI::SV2y", "TGSI::SV2z", "TGSI::SV2w", "TGSI::SV2", "TGSI::SV3x", "TGSI::SV3y", "TGSI::SV3z", "TGSI::SV3w", "TGSI::SV3", "TGSI::SV4x", "TGSI::SV4y", "TGSI::SV4z", "TGSI::SV4w", "TGSI::SV4", "TGSI::ADDR0x", "TGSI::ADDR0y", "TGSI::ADDR0z", "TGSI::ADDR0w", "TGSI::ADDR0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "Z80TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "Z80", "::", "Select8", ":", "case", "Z80", "::", "Select16", ":", "case", "Z80", "::", "Select24", ":", "return", "EmitLoweredSelect", "(", "MI", ",", "BB", ")", ";", "case", "Z80", "::", "SExt8", ":", "case", "Z80", "::", "SExt16", ":", "case", "Z80", "::", "SExt24", ":", "return", "EmitLoweredSExt", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unexpected instr type to insert\"", "Z80::Select8", "Z80::Select16", "Z80::Select24", "Z80::SExt8", "Z80::SExt16", "Z80::SExt24" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_fini", "(", "gcall", "*", "call", ",", "offload_attrs", "*", "oa", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "enum", "tree_code", "op", "=", "(", "enum", "tree_code", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "4", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "tree", "r", "=", "NULL_TREE", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", "&&", "oa", "->", "vector_length", "==", "PTX_WARP_SIZE", ")", "{", "for", "(", "int", "shfl", "=", "PTX_WARP_SIZE", "/", "2", ";", "shfl", ">", "0", ";", "shfl", "=", "shfl", ">>", "1", ")", "{", "tree", "other_var", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "nvptx_generate_vector_shuffle", "(", "gimple_location", "(", "call", ")", ",", "other_var", ",", "var", ",", "shfl", ",", "&", "seq", ")", ";", "r", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "gimplify_assign", "(", "r", ",", "fold_build2", "(", "op", ",", "TREE_TYPE", "(", "var", ")", ",", "var", ",", "other_var", ")", ",", "&", "seq", ")", ";", "var", "=", "r", ";", "}", "}", "else", "{", "tree", "accum", "=", "NULL_TREE", ";", "if", "(", "level", "==", "GOMP_DIM_WORKER", "||", "level", "==", "GOMP_DIM_VECTOR", ")", "{", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "5", ")", ";", "tree", "call", "=", "nvptx_get_shared_red_addr", "(", "TREE_TYPE", "(", "var", ")", ",", "offset", ",", "level", "==", "GOMP_DIM_VECTOR", ")", ";", "tree", "ptr", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "call", ")", ")", ";", "gimplify_assign", "(", "ptr", ",", "call", ",", "&", "seq", ")", ";", "accum", "=", "ptr", ";", "}", "else", "if", "(", "integer_zerop", "(", "ref_to_res", ")", ")", "r", "=", "var", ";", "else", "accum", "=", "ref_to_res", ";", "if", "(", "accum", ")", "{", "gsi_insert_seq_before", "(", "&", "gsi", ",", "seq", ",", "GSI_SAME_STMT", ")", ";", "seq", "=", "NULL", ";", "r", "=", "nvptx_reduction_update", "(", "gimple_location", "(", "call", ")", ",", "&", "gsi", ",", "accum", ",", "var", ",", "op", ",", "level", ")", ";", "}", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "r", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_FINI", "." ]

[ "nvptx", "1", "2", "3", "4", "2", "0", "1", "5" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SystemZAddressingMode", "::", "AddrForm", "Form", ";", "SystemZAddressingMode", "::", "DispRange", "DispRange", ";", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_S", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_T", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "}", "if", "(", "selectBDXAddr", "(", "Form", ",", "DispRange", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "SystemZ", "SystemZ", "SystemZAddressingMode::AddrForm", "SystemZAddressingMode::DispRange", "\"Unexpected asm memory constraint\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp20Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp20Only" ]

[]

[ "<s>", "MSP430Subtarget", "::", "MSP430Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "MSP430GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"e-m:e-p:16:16-i32:16:32-n8:16\"", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "DL", ")", "{", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "\"e-m:e-p:16:16-i32:16:32-n8:16\"" ]

[]

[ "<s>", "void", "AMDGPURegisterBankInfo", "::", "split64BitValueForMapping", "(", "MachineIRBuilder", "&", "B", ",", "SmallVector", "<", "unsigned", ",", "2", ">", "&", "Regs", ",", "unsigned", "Reg", ")", "const", "{", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "B", ".", "getMRI", "(", ")", ";", "unsigned", "LoLHS", "=", "MRI", "->", "createGenericVirtualRegister", "(", "S32", ")", ";", "unsigned", "HiLHS", "=", "MRI", "->", "createGenericVirtualRegister", "(", "S32", ")", ";", "const", "RegisterBank", "*", "Bank", "=", "getRegBank", "(", "Reg", ",", "*", "MRI", ",", "*", "TRI", ")", ";", "MRI", "->", "setRegBank", "(", "LoLHS", ",", "*", "Bank", ")", ";", "MRI", "->", "setRegBank", "(", "HiLHS", ",", "*", "Bank", ")", ";", "Regs", ".", "push_back", "(", "LoLHS", ")", ";", "Regs", ".", "push_back", "(", "HiLHS", ")", ";", "B", ".", "buildInstr", "(", "AMDGPU", "::", "G_UNMERGE_VALUES", ")", ".", "addDef", "(", "LoLHS", ")", ".", "addDef", "(", "HiLHS", ")", ".", "addUse", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Split", "64-bit", "value", "Reg", "into", "two", "32-bit", "halves", "and", "populate", "them", "into", "Regs", "." ]

[ "AMDGPU", "AMDGPU", "2", "32", "AMDGPU::G_UNMERGE_VALUES" ]

[]

[ "<s>", "bool", "SIMemoryLegalizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "SIMemOpAccess", "MOA", "(", "MF", ")", ";", "CC", "=", "SICacheControl", "::", "create", "(", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "BUNDLE", "&&", "MI", "->", "mayLoadOrStore", "(", ")", ")", "{", "MachineBasicBlock", "::", "instr_iterator", "II", "(", "MI", "->", "getIterator", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "++", "II", ",", "E", "=", "MBB", ".", "instr_end", "(", ")", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "I", "->", "unbundleFromPred", "(", ")", ";", "for", "(", "MachineOperand", "&", "MO", ":", "I", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", ")", "MO", ".", "setIsInternalRead", "(", "false", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "MI", "=", "II", "->", "getIterator", "(", ")", ";", "}", "if", "(", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "maybeAtomic", ")", ")", "continue", ";", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getLoadInfo", "(", "MI", ")", ")", "Changed", "|=", "expandLoad", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getStoreInfo", "(", "MI", ")", ")", "Changed", "|=", "expandStore", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicFenceInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicFence", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicCmpxchgOrRmwInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicCmpxchgOrRmw", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "}", "}", "Changed", "|=", "removeAtomicPseudoMIs", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SIInstrFlags::maybeAtomic" ]

[]

[ "<s>", "static", "bool", "arc_must_save_return_addr", "(", "struct", "function", "*", "func", ")", "{", "if", "(", "func", "->", "machine", "->", "frame_info", ".", "save_return_addr", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "return", "address", "must", "be", "saved", "in", "the", "current", "function", ",", "otherwise", "return", "false", "." ]

[ "arc" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MINA32 DAG->DAG Instruction Selection\"", ";", "}", "</s>" ]

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

[ "MINA32", "\"MINA32 DAG->DAG Instruction Selection\"" ]

[]

[ "<s>", "const", "RISCVTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "DecodeStatus", "ARCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "MCDisassembler", "::", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "uint8_t", "DecodeByte", "=", "(", "Bytes", "[", "1", "]", "&", "0xF7", ")", ">>", "3", ";", "if", "(", "DecodeByte", "<", "0x08", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "Fail", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "uint64_t", "Insn64", ";", "if", "(", "!", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn64", ")", ")", "return", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable64", ",", "Instr", ",", "Insn64", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Success", "==", "Result", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Successfully decoded 64-bit instruction.\"", ")", ";", "return", "Result", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Not a 64-bit instruction, falling back to 32-bit.\"", ")", ";", "}", "uint32_t", "Insn32", ";", "if", "(", "!", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn32", ")", ")", "{", "return", "Fail", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "Instr", ",", "Insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "6", ")", "{", "uint64_t", "Insn48", ";", "if", "(", "!", "readInstruction48", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn48", ")", ")", "return", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable48", ",", "Instr", ",", "Insn48", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Success", "==", "Result", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Successfully decoded 16-bit instruction with limm.\"", ")", ";", "return", "Result", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Not a 16-bit instruction with limm, try without it.\"", ")", ";", "}", "uint32_t", "Insn16", ";", "if", "(", "!", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn16", ")", ")", "return", "Fail", ";", "return", "decodeInstruction", "(", "DecoderTable16", ",", "Instr", ",", "Insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "}", "</s>" ]

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

[ "ARC", "ARC", "2", "0", "1", "0xF7", "3", "0x08", "4", "0", "8", "\"Successfully decoded 64-bit instruction.\"", "\"Not a 64-bit instruction, falling back to 32-bit.\"", "6", "\"Successfully decoded 16-bit instruction with limm.\"", "\"Not a 16-bit instruction with limm, try without it.\"" ]

[]

[ "<s>", "virtual", "const", "ARMBaseInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "romp_using_r14", "(", ")", "{", "return", "(", "write_symbols", "!=", "NO_DEBUG", "||", "current_function_profile", "||", "get_pool_size", "(", ")", "!=", "0", "||", "romp_makes_calls", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "will", "use", "r14", "as", "a", "pointer", "to", "its", "constant", "pool", "." ]

[ "romp", "0" ]

[]

[ "<s>", "const", "char", "*", "mips_output_sync_loop", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "mips_branch_likely", "=", "TARGET_FIX_R10000", ";", "mips_process_sync_loop", "(", "insn", ",", "operands", ")", ";", "mips_push_asm_switch", "(", "&", "mips_noreorder", ")", ";", "mips_push_asm_switch", "(", "&", "mips_nomacro", ")", ";", "mips_push_asm_switch", "(", "&", "mips_noat", ")", ";", "mips_start_ll_sc_sync_block", "(", ")", ";", "mips_multi_write", "(", ")", ";", "mips_end_ll_sc_sync_block", "(", ")", ";", "mips_pop_asm_switch", "(", "&", "mips_noat", ")", ";", "mips_pop_asm_switch", "(", "&", "mips_nomacro", ")", ";", "mips_pop_asm_switch", "(", "&", "mips_noreorder", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "and/or", "return", "the", "asm", "template", "for", "sync", "loop", "INSN", ",", "which", "has", "the", "operands", "given", "by", "OPERANDS", "." ]

[ "mips", "\"\"" ]

[]

[ "<s>", "bool", "TVMReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "TVM", "::", "NoRegister", "+", "1", ";", "PReg", "<", "TVM", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "TVM", "::", "VALUE_STACK", "||", "PReg", "==", "TVM", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "TVM", "::", "NoRegister", ";", "for", "(", "auto", "I", "=", "MRI", ".", "reg_begin", "(", "PReg", ")", ",", "E", "=", "MRI", ".", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", "++", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "TVM", "::", "NoRegister", ")", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MO", ".", "setReg", "(", "VReg", ")", ";", "if", "(", "MO", ".", "getParent", "(", ")", "->", "isDebugValue", "(", ")", ")", "MO", ".", "setIsDebug", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "TVM", "\"LiveIntervals shouldn't be active yet!\"", "TVM::NoRegister", "1", "TVM::NUM_TARGET_REGS", "TVM::VALUE_STACK", "TVM::ARGUMENTS", "TVM::NoRegister", "TVM::NoRegister" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "PIC16TargetLowering", "::", "getSetCCResultType", "(", "EVT", "ValType", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

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

[ "PIC16", "MVT::SimpleValueType", "PIC16", "MVT::i8" ]

[]

[ "<s>", "void", "initialize", "(", "Attributor", "&", "A", ")", "override", "{", "Function", "*", "F", "=", "getAssociatedFunction", "(", ")", ";", "CallingConv", "::", "ID", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "bool", "CallingConvSupportsAllImplicits", "=", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_Gfx", ")", ";", "if", "(", "AMDGPU", "::", "isGraphics", "(", "F", "->", "getCallingConv", "(", ")", ")", ")", "{", "indicatePessimisticFixpoint", "(", ")", ";", "return", ";", "}", "for", "(", "StringRef", "Attr", ":", "ImplicitAttrNames", ")", "{", "if", "(", "F", "->", "hasFnAttribute", "(", "Attr", ")", ")", "Attributes", ".", "insert", "(", "Attr", ")", ";", "}", "if", "(", "CallingConvSupportsAllImplicits", "&&", "F", "->", "hasAddressTaken", "(", "nullptr", ",", "true", ",", "true", ",", "true", ")", ")", "{", "for", "(", "StringRef", "AttrName", ":", "ImplicitAttrNames", ")", "{", "Attributes", ".", "insert", "(", "AttrName", ")", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isGraphics" ]

[]

[ "<s>", "static", "void", "s390_register_info_arg_fpr", "(", ")", "{", "int", "i", ";", "int", "min_stdarg_fpr", "=", "INT_MAX", ",", "max_stdarg_fpr", "=", "-", "1", ";", "int", "min_preserve_fpr", "=", "INT_MAX", ",", "max_preserve_fpr", "=", "-", "1", ";", "int", "min_fpr", ",", "max_fpr", ";", "if", "(", "cfun", "->", "stdarg", "&&", "TARGET_HARD_FLOAT", "&&", "cfun", "->", "va_list_fpr_size", "&&", "crtl", "->", "args", ".", "info", ".", "fprs", "<", "FP_ARG_NUM_REG", ")", "{", "min_stdarg_fpr", "=", "crtl", "->", "args", ".", "info", ".", "fprs", ";", "max_stdarg_fpr", "=", "min_stdarg_fpr", "+", "cfun", "->", "va_list_fpr_size", "-", "1", ";", "if", "(", "max_stdarg_fpr", ">=", "FP_ARG_NUM_REG", ")", "max_stdarg_fpr", "=", "FP_ARG_NUM_REG", "-", "1", ";", "min_stdarg_fpr", "+=", "FPR0_REGNUM", ";", "max_stdarg_fpr", "+=", "FPR0_REGNUM", ";", "}", "if", "(", "s390_preserve_args_p", "&&", "crtl", "->", "args", ".", "info", ".", "fprs", ")", "{", "min_preserve_fpr", "=", "FPR0_REGNUM", ";", "max_preserve_fpr", "=", "MIN", "(", "FPR0_REGNUM", "+", "FP_ARG_NUM_REG", "-", "1", ",", "FPR0_REGNUM", "+", "crtl", "->", "args", ".", "info", ".", "fprs", "-", "1", ")", ";", "}", "min_fpr", "=", "MIN", "(", "min_stdarg_fpr", ",", "min_preserve_fpr", ")", ";", "max_fpr", "=", "MAX", "(", "max_stdarg_fpr", ",", "max_preserve_fpr", ")", ";", "if", "(", "max_fpr", "==", "-", "1", ")", "return", ";", "for", "(", "i", "=", "min_fpr", ";", "i", "<=", "max_fpr", ";", "i", "++", ")", "cfun_set_fpr_save", "(", "i", ")", ";", "}", "</s>" ]

[ "Set", "the", "bits", "in", "fpr_bitmap", "for", "FPRs", "which", "need", "to", "be", "saved", "due", "to", "stdarg", "or", "-mpreserve-args", ".", "This", "is", "a", "helper", "routine", "for", "s390_register_info", "." ]

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

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WDC65816InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "WDC", "::", "AccRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "WDC", "::", "STAabsl", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC", "WDC::AccRegsRegClass", "WDC::STAabsl", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "bool", "s390_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "TARGET_VX", "&&", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", ")", "return", "0", ";", "if", "(", "!", "satisfies_constraint_j00", "(", "op", ")", "&&", "!", "satisfies_constraint_jm1", "(", "op", ")", "&&", "!", "satisfies_constraint_jKK", "(", "op", ")", "&&", "!", "satisfies_constraint_jxx", "(", "op", ")", "&&", "!", "satisfies_constraint_jyy", "(", "op", ")", ")", "return", "0", ";", "}", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "1", ";", "if", "(", "larl_operand", "(", "op", ",", "mode", ")", ")", "return", "1", ";", "if", "(", "TLS_SYMBOLIC_CONST", "(", "op", ")", ")", "return", "0", ";", "if", "(", "flag_pic", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "MSP430" ]

[]

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

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

[ "Patmos", "0", "0" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "InstructionCost", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", "=", "TTI", "::", "TCK_RecipThroughput", ",", "TTI", "::", "OperandValueKind", "Opd1Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueKind", "Opd2Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", "=", "TTI", "::", "OP_None", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", "=", "TTI", "::", "OP_None", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", "=", "ArrayRef", "<", "const", "Value", "*", ">", "(", ")", ",", "const", "Instruction", "*", "CxtI", "=", "nullptr", ")", "{", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "return", "64", "*", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "Lanai", "ISD::MUL", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "64" ]

[]

[ "<s>", "bool", "arm_validize_comparison", "(", "rtx", "*", "comparison", ",", "rtx", "*", "op1", ",", "rtx", "*", "op2", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "comparison", ")", ";", "int", "code_int", ";", "machine_mode", "mode", "=", "(", "GET_MODE", "(", "*", "op1", ")", "==", "VOIDmode", ")", "?", "GET_MODE", "(", "*", "op2", ")", ":", "GET_MODE", "(", "*", "op1", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "*", "op1", ")", "!=", "VOIDmode", "||", "GET_MODE", "(", "*", "op2", ")", "!=", "VOIDmode", ")", ";", "if", "(", "code", "==", "UNEQ", "||", "code", "==", "LTGT", ")", "return", "false", ";", "code_int", "=", "(", "int", ")", "code", ";", "arm_canonicalize_comparison", "(", "&", "code_int", ",", "op1", ",", "op2", ",", "0", ")", ";", "PUT_CODE", "(", "*", "comparison", ",", "(", "enum", "rtx_code", ")", "code_int", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "if", "(", "!", "arm_add_operand", "(", "*", "op1", ",", "mode", ")", ")", "*", "op1", "=", "force_reg", "(", "mode", ",", "*", "op1", ")", ";", "if", "(", "!", "arm_add_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "return", "true", ";", "case", "E_DImode", ":", "if", "(", "!", "cmpdi_operand", "(", "*", "op1", ",", "mode", ")", ")", "*", "op1", "=", "force_reg", "(", "mode", ",", "*", "op1", ")", ";", "if", "(", "!", "cmpdi_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "return", "true", ";", "case", "E_HFmode", ":", "if", "(", "!", "TARGET_VFP_FP16INST", ")", "break", ";", "mode", "=", "SFmode", ";", "*", "op1", "=", "convert_to_mode", "(", "mode", ",", "*", "op1", ",", "1", ")", ";", "*", "op2", "=", "convert_to_mode", "(", "mode", ",", "*", "op2", ",", "1", ")", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "if", "(", "!", "vfp_compare_operand", "(", "*", "op1", ",", "mode", ")", ")", "*", "op1", "=", "force_reg", "(", "mode", ",", "*", "op1", ")", ";", "if", "(", "!", "vfp_compare_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "valid", "comparison", "operation", "and", "makes", "the", "operands", "in", "a", "form", "that", "is", "valid", "." ]

[ "arm", "0", "1", "1" ]

[]

[ "<s>", "Optional", "<", "uint64_t", ">", "X86MCInstrAnalysis", "::", "evaluateMemoryOperandAddress", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "int", "MemOpStart", "=", "X86II", "::", "getMemoryOperandNo", "(", "MCID", ".", "TSFlags", ")", ";", "if", "(", "MemOpStart", "==", "-", "1", ")", "return", "None", ";", "MemOpStart", "+=", "X86II", "::", "getOperandBias", "(", "MCID", ")", ";", "const", "MCOperand", "&", "SegReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrSegmentReg", ")", ";", "const", "MCOperand", "&", "BaseReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrBaseReg", ")", ";", "const", "MCOperand", "&", "IndexReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrIndexReg", ")", ";", "const", "MCOperand", "&", "ScaleAmt", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrScaleAmt", ")", ";", "const", "MCOperand", "&", "Disp", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "SegReg", ".", "getReg", "(", ")", "!=", "0", "||", "IndexReg", ".", "getReg", "(", ")", "!=", "0", "||", "ScaleAmt", ".", "getImm", "(", ")", "!=", "1", "||", "!", "Disp", ".", "isImm", "(", ")", ")", "return", "None", ";", "if", "(", "BaseReg", ".", "getReg", "(", ")", "==", "X86", "::", "RIP", ")", "return", "Addr", "+", "Size", "+", "Disp", ".", "getImm", "(", ")", ";", "return", "None", ";", "}", "</s>" ]

[ "Given", "an", "instruction", "tries", "to", "get", "the", "address", "of", "a", "memory", "operand", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "1", "X86II::getOperandBias", "X86::AddrSegmentReg", "X86::AddrBaseReg", "X86::AddrIndexReg", "X86::AddrScaleAmt", "X86::AddrDisp", "0", "0", "1", "X86::RIP" ]

[]

[ "<s>", "MCContext", "&", "getContext", "(", ")", "const", "{", "return", "Streamer", ".", "getContext", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "LLVMContext", "used", "by", "the", "analysis", "." ]

[ "SHUXI" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Wasn't expecting to be able to lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for PPC\"", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "Op", ".", "getDebugLoc", "(", ")", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Wasn't expecting to be able to lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "\"TLS not implemented for PPC\"", "ISD::JumpTable", "ISD::SETCC", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::VASTART", "PPC", "ISD::VAARG", "PPC", "ISD::STACKRESTORE", "PPC", "ISD::DYNAMIC_STACKALLOC", "PPC", "ISD::SELECT_CC", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::FLT_ROUNDS_", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SCALAR_TO_VECTOR", "ISD::MUL", "ISD::RETURNADDR", "ISD::FRAMEADDR" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isGAPlusOffset", "(", "SDNode", "*", "N", ",", "const", "GlobalValue", "*", "&", "GA", ",", "int64_t", "&", "Offset", ")", "const", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "Wrapper", ")", "{", "if", "(", "isa", "<", "GlobalAddressSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", ")", "{", "GA", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getGlobal", "(", ")", ";", "Offset", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getOffset", "(", ")", ";", "return", "true", ";", "}", "}", "return", "TargetLowering", "::", "isGAPlusOffset", "(", "N", ",", "GA", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "(", "and", "the", "GlobalValue", "and", "the", "offset", ")", "if", "the", "node", "is", "a", "GlobalAddress", "+", "offset", "." ]

[ "X86", "X86", "X86ISD::Wrapper", "0", "0", "0" ]

[]

[ "<s>", "void", "SPURegisterInfo", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "Align", "=", "std", "::", "max", "(", "TargetAlign", ",", "MFI", "->", "getMaxAlignment", "(", ")", ")", ";", "assert", "(", "isPowerOf2_32", "(", "Align", ")", "&&", "\"Alignment is not power of 2\"", ")", ";", "unsigned", "AlignMask", "=", "Align", "-", "1", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "\"Alignment is not power of 2\"", "1" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "static", "const", "LoadStoreMethod", "PossibleClasses", "[", "]", "=", "{", "{", "&", "AArch64", "::", "GPR64RegClass", ",", "AArch64", "::", "LSPair64_LDR", ",", "AArch64", "::", "LS64_LDR", "}", ",", "{", "&", "AArch64", "::", "FPR64RegClass", ",", "AArch64", "::", "LSFPPair64_LDR", ",", "AArch64", "::", "LSFP64_LDR", "}", ",", "}", ";", "const", "unsigned", "NumClasses", "=", "llvm", "::", "array_lengthof", "(", "PossibleClasses", ")", ";", "emitFrameMemOps", "(", "false", ",", "MBB", ",", "MBBI", ",", "CSI", ",", "TRI", ",", "PossibleClasses", ",", "NumClasses", ")", ";", "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", "(", ")", "." ]

[ "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LSPair64_LDR", "AArch64::LS64_LDR", "AArch64::FPR64RegClass", "AArch64::LSFPPair64_LDR", "AArch64::LSFP64_LDR" ]

[]

[ "<s>", "virtual", "void", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DEBUG", "(", "HazardRec", "->", "dumpState", "(", ")", ";", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "SystemZ", "SystemZ" ]

[]

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

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

[ "Hexagon" ]

[]