Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "tree", "altivec_build_resolved_builtin", "(", "tree", "*", "args", ",", "int", "n", ",", "const", "struct", "altivec_builtin_types", "*", "desc", ")", "{", "tree", "impl_fndecl", "=", "rs6000_builtin_decls", "[", "desc", "->", "overloaded_code", "]", ";", "tree", "ret_type", "=", "rs6000_builtin_type", "(", "desc", "->", "ret_type", ")", ";", "tree", "argtypes", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "impl_fndecl", ")", ")", ";", "tree", "arg_type", "[", "3", "]", ";", "tree", "call", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "arg_type", "[", "i", "]", "=", "TREE_VALUE", "(", "argtypes", ")", ",", "argtypes", "=", "TREE_CHAIN", "(", "argtypes", ")", ";", "if", "(", "desc", "->", "code", "==", "ALTIVEC_BUILTIN_VEC_VCMPGE_P", "&&", "desc", "->", "overloaded_code", "!=", "ALTIVEC_BUILTIN_VCMPGEFP_P", "&&", "desc", "->", "overloaded_code", "!=", "VSX_BUILTIN_XVCMPGEDP_P", ")", "{", "tree", "t", ";", "t", "=", "args", "[", "2", "]", ",", "args", "[", "2", "]", "=", "args", "[", "1", "]", ",", "args", "[", "1", "]", "=", "t", ";", "t", "=", "arg_type", "[", "2", "]", ",", "arg_type", "[", "2", "]", "=", "arg_type", "[", "1", "]", ",", "arg_type", "[", "1", "]", "=", "t", ";", "args", "[", "0", "]", "=", "fold_build2", "(", "BIT_XOR_EXPR", ",", "TREE_TYPE", "(", "args", "[", "0", "]", ")", ",", "args", "[", "0", "]", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ")", ";", "}", "switch", "(", "n", ")", "{", "case", "0", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "0", ")", ";", "break", ";", "case", "1", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "1", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ")", ";", "break", ";", "case", "2", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "2", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ")", ";", "break", ";", "case", "3", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "3", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "2", "]", ",", "args", "[", "2", "]", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "fold_convert", "(", "ret_type", ",", "call", ")", ";", "}", "</s>" ]

[ "Build", "a", "tree", "for", "a", "function", "call", "to", "an", "Altivec", "non-overloaded", "builtin", ".", "The", "overloaded", "builtin", "that", "matched", "the", "types", "and", "args", "is", "described", "by", "DESC", ".", "The", "N", "arguments", "are", "given", "in", "ARGS", ",", "respectively", ".", "Actually", "the", "only", "thing", "it", "does", "is", "calling", "fold_convert", "on", "ARGS", ",", "with", "a", "small", "exception", "for", "vec_", "{", "all", ",", "any", "}", "_", "{", "ge", ",", "le", "}", "predicates", "." ]

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

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "bool", "GCNPreRAOptimizations", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Register", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "!", "LIS", "->", "hasInterval", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->", "getRegClass", "(", "Reg", ")", ";", "if", "(", "RC", "->", "MC", "->", "getSizeInBits", "(", ")", "!=", "64", "||", "!", "TRI", "->", "isSGPRClass", "(", "RC", ")", ")", "continue", ";", "Changed", "|=", "processReg", "(", "Reg", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "64" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Four", "=", "MCConstantExpr", "::", "Create", "(", "4", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateAdd", "(", "Res", ",", "Four", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

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

[]

[ "<s>", "bool", "HexagonGenInsert", "::", "removeDeadCode", "(", "MachineDomTreeNode", "*", "N", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "DTN", ":", "children", "<", "MachineDomTreeNode", "*", ">", "(", "N", ")", ")", "Changed", "|=", "removeDeadCode", "(", "DTN", ")", ";", "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "auto", "I", "=", "B", "->", "rbegin", "(", ")", ",", "E", "=", "B", "->", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Instrs", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "auto", "I", "=", "Instrs", ".", "begin", "(", ")", ",", "E", "=", "Instrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Regs", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "R", ")", "||", "!", "MRI", "->", "use_nodbg_empty", "(", "R", ")", ")", "{", "AllDead", "=", "false", ";", "break", ";", "}", "Regs", ".", "push_back", "(", "R", ")", ";", "}", "if", "(", "!", "AllDead", ")", "continue", ";", "B", "->", "erase", "(", "MI", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "N", "=", "Regs", ".", "size", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "MRI", "->", "markUsesInDebugValueAsUndef", "(", "Regs", "[", "I", "]", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "2", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "canExecuteInBundle", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Second", ")", "const", "{", "if", "(", "DisableNVSchedule", ")", "return", "false", ";", "if", "(", "mayBeNewStore", "(", "Second", ")", ")", "{", "const", "MachineOperand", "&", "Stored", "=", "Second", ".", "getOperand", "(", "Second", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "!", "Stored", ".", "isReg", "(", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "First", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "Op", "=", "First", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isDef", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "Stored", ".", "getReg", "(", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Can", "these", "instructions", "execute", "at", "the", "same", "time", "in", "a", "bundle", "." ]

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

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStBaseOp", "(", "const", "MachineInstr", "*", "MI", ")", "{", "return", "MI", "->", "getOperand", "(", "1", ")", ";", "}", "</s>" ]

[ "Returns", "the", "base", "register", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "1" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "Op", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "Op", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Custom lowering not defined for operation\"", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalAddress", "ISD::INTRINSIC_W_CHAIN", "ISD::BUILD_VECTOR", "ISD::EXTRACT_SUBVECTOR", "ISD::CONCAT_VECTORS", "\"Custom lowering not defined for operation\"" ]

[]

[ "<s>", "static", "rtx", "ix86_static_chain", "(", "const_tree", "fndecl_or_type", ",", "bool", "incoming_p", ")", "{", "unsigned", "regno", ";", "if", "(", "DECL_P", "(", "fndecl_or_type", ")", "&&", "!", "DECL_STATIC_CHAIN", "(", "fndecl_or_type", ")", ")", "return", "NULL", ";", "if", "(", "TARGET_64BIT", ")", "{", "regno", "=", "R10_REG", ";", "}", "else", "{", "const_tree", "fntype", ",", "fndecl", ";", "unsigned", "int", "ccvt", ";", "regno", "=", "CX_REG", ";", "if", "(", "TREE_CODE", "(", "fndecl_or_type", ")", "==", "FUNCTION_DECL", ")", "{", "fntype", "=", "TREE_TYPE", "(", "fndecl_or_type", ")", ";", "fndecl", "=", "fndecl_or_type", ";", "}", "else", "{", "fntype", "=", "fndecl_or_type", ";", "fndecl", "=", "NULL", ";", "}", "ccvt", "=", "ix86_get_callcvt", "(", "fntype", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "{", "regno", "=", "AX_REG", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "{", "regno", "=", "AX_REG", ";", "}", "else", "if", "(", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", "==", "3", ")", "{", "if", "(", "incoming_p", ")", "{", "if", "(", "fndecl", "==", "current_function_decl", ")", "ix86_static_chain_on_stack", "=", "true", ";", "return", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "8", ")", ")", ";", "}", "regno", "=", "SI_REG", ";", "}", "}", "return", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Find", "a", "location", "for", "the", "static", "chain", "incoming", "to", "a", "nested", "function", ".", "This", "is", "a", "register", ",", "unless", "all", "free", "registers", "are", "used", "by", "arguments", "." ]

[ "i386", "0", "0", "3", "8" ]

[]

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

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

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

[]

[ "<s>", "bool", "contains", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "override", "{", "return", "Region", "->", "contains", "(", "MBB", ")", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "ARMRelocator", "::", "Result", "unsupported", "(", "Relocation", "&", "pReloc", ",", "ARMRelocator", "&", "pParent", ")", "{", "return", "Relocator", "::", "Unsupported", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "*", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "selectMipsCPU", "(", "TargetTriple", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", "->", "Options", ".", "UseSoftFloat", ")", "{", "TM", "->", "Options", ".", "UseSoftFloat", "=", "true", ";", "TM", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "InMips16HardFloat", "=", "true", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "main", "(", ")", "{", "int", "i", ",", "j", ";", "double", "q", ",", "r", ",", "err", ",", "max_err", "=", "0", ",", "max_s_err", "=", "0", ";", "puts", "(", "\"/* This table has been generated by divtab-sh4.cc. */\"", ")", ";", "puts", "(", "\"\\t.balign 4\"", ")", ";", "for", "(", "i", "=", "-", "128", ";", "i", "<", "128", ";", "i", "++", ")", "{", "int", "n", "=", "0", ";", "if", "(", "i", "==", "0", ")", "{", "puts", "(", "\"LOCAL(div_table_clz):\\n\\t.byte\\t0\"", ")", ";", "continue", ";", "}", "for", "(", "j", "=", "i", "<", "0", "?", "-", "i", ":", "i", ";", "j", "<", "128", ";", "j", "+=", "j", ")", "n", "++", ";", "printf", "(", "\"\\t.byte\\t%d\\n\"", ",", "n", "-", "7", ")", ";", "}", "puts", "(", "\"\\ /* 1/-128 .. 1/127, normalized. There is an implicit leading 1 in bit 32,\\n\\ or in bit 33 for powers of two. */\\n\\ .balign 4\"", ")", ";", "for", "(", "i", "=", "-", "128", ";", "i", "<", "128", ";", "i", "++", ")", "{", "if", "(", "i", "==", "0", ")", "{", "puts", "(", "\"LOCAL(div_table_inv):\\n\\t.long\\t0x0\"", ")", ";", "continue", ";", "}", "j", "=", "i", "<", "0", "?", "-", "i", ":", "i", ";", "while", "(", "j", "<", "64", ")", "j", "+=", "j", ";", "q", "=", "4.", "*", "(", "1", "<<", "30", ")", "*", "128", "/", "j", ";", "r", "=", "ceil", "(", "q", ")", ";", "printf", "(", "\"\\t.long\\t0x%X\\n\"", ",", "(", "unsigned", ")", "r", ")", ";", "err", "=", "r", "-", "q", ";", "if", "(", "err", ">", "max_err", ")", "max_err", "=", "err", ";", "err", "=", "err", "*", "j", "/", "128", ";", "if", "(", "err", ">", "max_s_err", ")", "max_s_err", "=", "err", ";", "}", "printf", "(", "\"\\t/* maximum error: %f scaled: %f*/\\n\"", ",", "max_err", ",", "max_s_err", ")", ";", "exit", "(", "0", ")", ";", "}", "</s>" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "sh", "0", "0", "\"/* This table has been generated by divtab-sh4.cc. */\"", "\"\\t.balign 4\"", "128", "128", "0", "0", "\"LOCAL(div_table_clz):\\n\\t.byte\\t0\"", "0", "128", "\"\\t.byte\\t%d\\n\"", "7", "\"\\ /* 1/-128 .. 1/127, normalized. There is an implicit leading 1 in bit 32,\\n\\ or in bit 33 for powers of two. */\\n\\ .balign 4\"", "128", "128", "0", "\"LOCAL(div_table_inv):\\n\\t.long\\t0x0\"", "0", "64", "4.", "1", "30", "128", "\"\\t.long\\t0x%X\\n\"", "128", "\"\\t/* maximum error: %f scaled: %f*/\\n\"", "0" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "unsigned", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "&", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "&", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Arg", ".", "getType", "(", ")", ")", "==", "0", ")", "continue", ";", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "uint64_t", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasCustomCallingConv", "(", ")", ")", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "UpdateCustomCalleeSavedRegs", "(", "MF", ")", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "0", "0", "AArch64", "AArch64", "AArch64", "8", "AArch64", "AArch64", "4", "AArch64" ]

[]

[ "<s>", "bool", "LanaiTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "(", "isGlobalInSmallSectionImpl", "(", "GO", ",", "TM", ")", "&&", "(", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "const", "uint16_t", "*", "AVRRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "return", "(", "(", "CC", "==", "CallingConv", "::", "AVR_INTR", "||", "CC", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "CSR_Interrupts_SaveList", ":", "CSR_Normal_SaveList", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "AMDGPUInstructionSelector", "::", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "&", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "{", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "n8_consumed_by_ex_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "if", "(", "movd44_even_dep_p", "(", "consumer", ",", "def_reg", ")", ")", "return", "true", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "consumer", ")", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "0", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "extract_branch_condition_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "if", "(", "!", "post_update_insn_p", "(", "consumer", ")", "&&", "!", "immed_offset_p", "(", "extract_mem_rtx", "(", "consumer", ")", ")", ")", "return", "false", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_nth_access_rtx", "(", "consumer", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isLikeA9", "(", ")", ")", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "RangeTree", "::", "dump", "(", "const", "Node", "*", "N", ")", "const", "{", "dbgs", "(", ")", "<<", "\"Node: \"", "<<", "N", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Height: \"", "<<", "N", "->", "Height", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Count: \"", "<<", "N", "->", "Count", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" MaxEnd: \"", "<<", "N", "->", "MaxEnd", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Range: \"", "<<", "N", "->", "Range", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Left: \"", "<<", "N", "->", "Left", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Right: \"", "<<", "N", "->", "Right", "<<", "\"\\n\\n\"", ";", "if", "(", "N", "->", "Left", ")", "dump", "(", "N", "->", "Left", ")", ";", "if", "(", "N", "->", "Right", ")", "dump", "(", "N", "->", "Right", ")", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "Hexagon", "\"Node: \"", "\" Height: \"", "\" Count: \"", "\" MaxEnd: \"", "\" Range: \"", "\" Left: \"", "\" Right: \"", "\"\\n\\n\"" ]

[]

[ "<s>", "TargetIRAnalysis", "AMDGPUTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AMDGPUTTIImpl", "(", "this", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "R600" ]

[]

[ "<s>", "ARMConstantPoolMBB", "*", "ARMConstantPoolMBB", "::", "Create", "(", "LLVMContext", "&", "C", ",", "const", "MachineBasicBlock", "*", "mbb", ",", "unsigned", "ID", ",", "unsigned", "char", "PCAdj", ")", "{", "return", "new", "ARMConstantPoolMBB", "(", "C", ",", "mbb", ",", "ID", ",", "PCAdj", ",", "ARMCP", "::", "no_modifier", ",", "false", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMCP::no_modifier" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isCommutativeBinOp", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "PMULUDQ", ":", "return", "true", ";", "}", "return", "TargetLoweringBase", "::", "isCommutativeBinOp", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "opcode", "is", "a", "commutative", "binary", "operation", "." ]

[ "X86", "X86", "X86ISD::PMULUDQ" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPULowerKernelAttributesPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "StringRef", "DispatchPtrName", "=", "Intrinsic", "::", "getName", "(", "Intrinsic", "::", "amdgcn_dispatch_ptr", ")", ";", "Function", "*", "DispatchPtr", "=", "F", ".", "getParent", "(", ")", "->", "getFunction", "(", "DispatchPtrName", ")", ";", "if", "(", "!", "DispatchPtr", ")", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "if", "(", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "CI", "->", "getCalledFunction", "(", ")", "==", "DispatchPtr", ")", "processUse", "(", "CI", ")", ";", "}", "}", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU", "Intrinsic::getName", "Intrinsic::amdgcn_dispatch_ptr" ]

[]

[ "<s>", "enum", "riscv_symbol_type", "riscv_classify_symbolic_expression", "(", "rtx", "x", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "x", ")", ")", "return", "UNSPEC_ADDRESS_TYPE", "(", "x", ")", ";", "return", "riscv_classify_symbol", "(", "x", ")", ";", "}", "</s>" ]

[ "Classify", "the", "base", "of", "symbolic", "expression", "X", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "riscv_expand_prologue", "(", "void", ")", "{", "struct", "riscv_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "size", "=", "frame", "->", "total_size", ";", "unsigned", "mask", "=", "frame", "->", "mask", ";", "rtx", "insn", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "return", ";", "if", "(", "riscv_use_save_libcall", "(", "frame", ")", ")", "{", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "riscv_adjust_libcall_cfi_prologue", "(", ")", ";", "size", "-=", "frame", "->", "save_libcall_adjustment", ";", "insn", "=", "emit_insn", "(", "riscv_gen_gpr_save_insn", "(", "frame", ")", ")", ";", "frame", "->", "mask", "=", "0", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "step1", "=", "MIN", "(", "size", ",", "riscv_first_stack_step", "(", "frame", ")", ")", ";", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "step1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "size", "-=", "step1", ";", "riscv_for_each_saved_reg", "(", "size", ",", "riscv_save_reg", ",", "false", ",", "false", ")", ";", "}", "frame", "->", "mask", "=", "mask", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "frame", "->", "hard_frame_pointer_offset", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "riscv_emit_stack_tie", "(", ")", ";", "}", "if", "(", "size", ">", "0", ")", "{", "if", "(", "SMALL_OPERAND", "(", "-", "size", ")", ")", "{", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "}", "else", "{", "riscv_emit_move", "(", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ")", ")", ";", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "size", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "riscv_set_frame_expr", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "``", "prologue", "''", "pattern", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "nios2_valid_compare_const_p", "(", "enum", "rtx_code", "code", ",", "rtx", "op", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "GE", ":", "case", "LT", ":", "return", "SMALL_INT", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "GEU", ":", "case", "LTU", ":", "return", "SMALL_INT_UNSIGNED", "(", "INTVAL", "(", "op", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "constant", "comparison", "is", "supported", "by", "nios2", "." ]

[ "nios2" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "GV", "->", "hasDLLImportLinkage", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "bool", "isDecl", "=", "GV", "->", "hasAvailableExternallyLinkage", "(", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", "&&", "!", "GV", "->", "isMaterializable", "(", ")", ")", "isDecl", "=", "true", ";", "if", "(", "isPICStyleRIPRel", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDefaultVisibility", "(", ")", "&&", "(", "isDecl", "||", "GV", "->", "isWeakForLinker", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "else", "if", "(", "!", "isTargetWin64", "(", ")", ")", "{", "assert", "(", "isTargetELF", "(", ")", "&&", "\"Unknown rip-relative target\"", ")", ";", "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isPICStyleGOT", "(", ")", ")", "{", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", "||", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTOFF", ";", "return", "X86II", "::", "MO_GOT", ";", "}", "if", "(", "isPICStyleStubPIC", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "if", "(", "isDecl", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "return", "X86II", "::", "MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "if", "(", "isPICStyleStubNoDynamic", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_DLLIMPORT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "\"Unknown rip-relative target\"", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_GOT", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureGCN3Encoding", "]", ")", "report_fatal_error", "(", "\"Disassembly not yet supported for subtarget\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "int", "Src2ModIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "auto", "I", "=", "MI", ".", "begin", "(", ")", ";", "std", "::", "advance", "(", "I", ",", "Src2ModIdx", ")", ";", "MI", ".", "insert", "(", "I", ",", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::FeatureGCN3Encoding", "\"Disassembly not yet supported for subtarget\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "AMDGPU::V_MAC_F32_e64_vi", "AMDGPU::V_MAC_F32_e64_si", "AMDGPU::V_MAC_F16_e64_vi", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "0" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "getMCOpcodeFromPseudo", "(", "Opc", ")", ";", "unsigned", "DescSize", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "isFixedSize", "(", "MI", ")", ")", "return", "DescSize", ";", "if", "(", "isVALU", "(", "MI", ")", "||", "isSALU", "(", "MI", ")", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src0Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src0Idx", "]", ")", ")", "return", "DescSize", "+", "4", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src1Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src1Idx", "]", ")", ")", "return", "DescSize", "+", "4", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "Src2Idx", "==", "-", "1", ")", "return", "DescSize", ";", "if", "(", "isLiteralConstantLike", "(", "MI", ".", "getOperand", "(", "Src2Idx", ")", ",", "Desc", ".", "OpInfo", "[", "Src2Idx", "]", ")", ")", "return", "DescSize", "+", "4", ";", "return", "DescSize", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "return", "0", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleSize", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "default", ":", "return", "DescSize", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "4", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "4", "0", "0" ]

[]

[ "<s>", "static", "enum", "flt_eval_method", "s390_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE", ";", "case", "EXCESS_PRECISION_TYPE_FLOAT16", ":", "error", "(", "\"%<-fexcess-precision=16%> is not supported on this target\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>" ]

[ "Implement", "TARGET_C_EXCESS_PRECISION", "to", "maintain", "historic", "behavior", "with", "older", "glibc", "versions", "For", "historical", "reasons", ",", "float_t", "and", "double_t", "had", "been", "typedef'ed", "to", "double", "on", "s390", ",", "causing", "operations", "on", "float_t", "to", "operate", "in", "a", "higher", "precision", "than", "is", "necessary", ".", "However", ",", "it", "is", "not", "the", "case", "that", "SFmode", "operations", "have", "implicit", "excess", "precision", ",", "and", "we", "generate", "more", "optimal", "code", "if", "we", "let", "the", "compiler", "know", "no", "implicit", "extra", "precision", "is", "added", ".", "With", "a", "glibc", "with", "that", "``", "historic", "''", "definition", ",", "configure", "will", "enable", "this", "hook", "to", "set", "FLT_EVAL_METHOD", "to", "1", "for", "-fexcess-precision=standard", "(", "e.g.", ",", "as", "implied", "by", "-std=cXY", ")", ".", "That", "means", "when", "we", "are", "compiling", "with", "-fexcess-precision=fast", ",", "the", "value", "we", "set", "for", "FLT_EVAL_METHOD", "will", "be", "out", "of", "line", "with", "the", "actual", "precision", "of", "float_t", ".", "Newer", "versions", "of", "glibc", "will", "be", "modified", "to", "derive", "the", "definition", "of", "float_t", "from", "FLT_EVAL_METHOD", "on", "s390x", ",", "as", "on", "many", "other", "architectures", ".", "There", ",", "configure", "will", "disable", "this", "hook", "by", "default", ",", "so", "that", "we", "defer", "to", "the", "default", "of", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", "and", "a", "resulting", "typedef", "of", "float_t", "to", "float", ".", "Note", "that", "in", "that", "scenario", ",", "float_t", "and", "FLT_EVAL_METHOD", "will", "be", "in", "line", "independent", "of", "-fexcess-precision", "." ]

[ "s390", "\"%<-fexcess-precision=16%> is not supported on this target\"" ]

[]

[ "<s>", "EVT", "M68kTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "MVT::i8" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "BPFTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "BPF", "::", "GPRRegClass", ")", ";", "default", ":", "break", ";", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "1", "0", "0U", "BPF::GPRRegClass" ]

[]

[ "<s>", "bool", "builtin_type_p", "(", "const_tree", "type", ",", "unsigned", "int", "*", "num_zr", ",", "unsigned", "int", "*", "num_pr", ")", "{", "if", "(", "tree", "attr", "=", "lookup_sve_type_attribute", "(", "type", ")", ")", "{", "tree", "num_zr_node", "=", "TREE_VALUE", "(", "attr", ")", ";", "tree", "num_pr_node", "=", "TREE_CHAIN", "(", "num_zr_node", ")", ";", "*", "num_zr", "=", "tree_to_uhwi", "(", "TREE_VALUE", "(", "num_zr_node", ")", ")", ";", "*", "num_pr", "=", "tree_to_uhwi", "(", "TREE_VALUE", "(", "num_pr_node", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "is", "a", "built-in", "SVE", "type", "defined", "by", "the", "ABI", "or", "ACLE", ".", "If", "so", ",", "store", "the", "number", "of", "constituent", "SVE", "vectors", "in", "*", "NUM_ZR", "and", "the", "number", "of", "constituent", "SVE", "predicates", "in", "*", "NUM_PR", "." ]

[ "aarch64" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MSP430TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MSP430", "::", "GR8RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MSP430", "::", "GR16RegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "1", "0", "MVT::i8", "0U", "MSP430::GR8RegClass", "0U", "MSP430::GR16RegClass" ]

[]

[ "<s>", "void", "updateDebugInfo", "(", "MachineInstr", "*", "MI", ",", "const", "DILocation", "*", "Loc", ")", "{", "DebugLoc", "DL", "(", "Loc", ")", ";", "MI", "->", "setDebugLoc", "(", "DL", ")", ";", "}", "</s>" ]

[ "Called", "to", "update", "debug", "info", "associated", "with", "the", "instruction", "." ]

[ "X86" ]

[]

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

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

[ "AMDGPU" ]

[]

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

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

[ "Nios2" ]

[]

[ "<s>", "static", "rtx", "riscv_pass_fpr_single", "(", "enum", "machine_mode", "type_mode", ",", "unsigned", "regno", ",", "enum", "machine_mode", "value_mode", ")", "{", "rtx", "x", "=", "gen_rtx_REG", "(", "value_mode", ",", "regno", ")", ";", "if", "(", "type_mode", "!=", "value_mode", ")", "{", "x", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "x", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "type_mode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Return", "the", "representation", "of", "an", "argument", "passed", "or", "returned", "in", "an", "FPR", "when", "the", "value", "has", "mode", "VALUE_MODE", "and", "the", "type", "has", "TYPE_MODE", ".", "The", "two", "modes", "may", "be", "different", "for", "structures", "like", ":", "struct", "__attribute__", "(", "(", "packed", ")", ")", "foo", "{", "float", "f", ";", "}", "where", "the", "SFmode", "value", "``", "f", "''", "is", "passed", "in", "REGNO", "but", "the", "struct", "itself", "has", "mode", "BLKmode", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "MipsSETargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "MipsCC", "&", "MipsCCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "MipsFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableMipsTailCalls", ")", "return", "false", ";", "if", "(", "MipsCCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "riscv_register_move_cost", "(", "enum", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "return", "SECONDARY_MEMORY_NEEDED", "(", "from", ",", "to", ",", "mode", ")", "?", "8", ":", "2", ";", "}", "</s>" ]

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

[ "riscv", "8", "2" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getIndirectSymViaGOTPCRel", "(", "const", "MCSymbol", "*", "Sym", ",", "const", "MCValue", "&", "MV", ",", "int64_t", "Offset", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "unsigned", "FinalOff", "=", "Offset", "+", "MV", ".", "getConstant", "(", ")", "+", "4", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Off", "=", "MCConstantExpr", "::", "Create", "(", "FinalOff", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateAdd", "(", "Res", ",", "Off", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "target", "specific", "PC", "relative", "GOT", "entry", "relocation", "." ]

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

[]

[ "<s>", "static", "unsigned", "int", "convert_scalars_to_vector", "(", ")", "{", "basic_block", "bb", ";", "bitmap", "candidates", ";", "int", "converted_insns", "=", "0", ";", "bitmap_obstack_initialize", "(", "NULL", ")", ";", "candidates", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "calculate_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "df_set_flags", "(", "DF_DEFER_INSN_RESCAN", ")", ";", "df_chain_add_problem", "(", "DF_DU_CHAIN", "|", "DF_UD_CHAIN", ")", ";", "df_md_add_problem", "(", ")", ";", "df_analyze", "(", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Searching for mode conversion candidates...\\n\"", ")", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "scalar_to_vector_candidate_p", "(", "insn", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" insn %d is marked as a candidate\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "bitmap_set_bit", "(", "candidates", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "remove_non_convertible_regs", "(", "candidates", ")", ";", "if", "(", "bitmap_empty_p", "(", "candidates", ")", ")", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"There are no candidates for optimization.\\n\"", ")", ";", "while", "(", "!", "bitmap_empty_p", "(", "candidates", ")", ")", "{", "unsigned", "uid", "=", "bitmap_first_set_bit", "(", "candidates", ")", ";", "scalar_chain", "chain", ";", "chain", ".", "build", "(", "candidates", ",", "uid", ")", ";", "if", "(", "chain", ".", "compute_convert_gain", "(", ")", ">", "0", ")", "converted_insns", "+=", "chain", ".", "convert", "(", ")", ";", "else", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Chain #%d conversion is not profitable\\n\"", ",", "chain", ".", "chain_id", ")", ";", "}", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Total insns converted: %d\\n\"", ",", "converted_insns", ")", ";", "BITMAP_FREE", "(", "candidates", ")", ";", "bitmap_obstack_release", "(", "NULL", ")", ";", "df_process_deferred_rescans", "(", ")", ";", "if", "(", "converted_insns", ")", "{", "if", "(", "crtl", "->", "stack_alignment_needed", "<", "128", ")", "crtl", "->", "stack_alignment_needed", "=", "128", ";", "if", "(", "crtl", "->", "stack_alignment_estimated", "<", "128", ")", "crtl", "->", "stack_alignment_estimated", "=", "128", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Main", "STV", "pass", "function", ".", "Find", "and", "convert", "scalar", "instructions", "into", "vector", "mode", "when", "profitable", "." ]

[ "i386", "0", "\"Searching for mode conversion candidates...\\n\"", "\" insn %d is marked as a candidate\\n\"", "\"There are no candidates for optimization.\\n\"", "0", "\"Chain #%d conversion is not profitable\\n\"", "\"Total insns converted: %d\\n\"", "128", "128", "128", "128", "0" ]

[]

[ "<s>", "int", "mips_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "COPY_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ")", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ")", "{", "if", "(", "HARD_REGNO_MODE_OK", "(", "ST_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "HARD_REGNO_MODE_OK", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ".", "Usually", "all", "registers", "are", "word-sized", ".", "The", "only", "supported", "exception", "is", "-mgp64", "-msingle-float", ",", "which", "has", "64-bit", "words", "but", "32-bit", "float", "registers", ".", "A", "word-based", "calculation", "is", "correct", "even", "in", "that", "case", ",", "since", "-msingle-float", "disallows", "multi-FPR", "values", ".", "The", "FP", "status", "registers", "are", "an", "exception", "to", "this", "rule", ".", "They", "are", "always", "4", "bytes", "wide", "as", "they", "only", "hold", "condition", "code", "modes", ",", "and", "CCmode", "is", "always", "considered", "to", "be", "4", "bytes", "wide", "." ]

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

[]

[ "<s>", "static", "void", "s390_register_info_arg_gpr", "(", ")", "{", "int", "i", ";", "int", "min_stdarg_gpr", "=", "INT_MAX", ",", "max_stdarg_gpr", "=", "-", "1", ";", "int", "min_preserve_gpr", "=", "INT_MAX", ",", "max_preserve_gpr", "=", "-", "1", ";", "int", "min_gpr", ",", "max_gpr", ";", "if", "(", "cfun", "->", "stdarg", "&&", "cfun", "->", "va_list_gpr_size", "&&", "crtl", "->", "args", ".", "info", ".", "gprs", "<", "GP_ARG_NUM_REG", ")", "{", "min_stdarg_gpr", "=", "crtl", "->", "args", ".", "info", ".", "gprs", ";", "max_stdarg_gpr", "=", "min_stdarg_gpr", "+", "cfun", "->", "va_list_gpr_size", "-", "1", ";", "if", "(", "max_stdarg_gpr", ">=", "GP_ARG_NUM_REG", ")", "max_stdarg_gpr", "=", "GP_ARG_NUM_REG", "-", "1", ";", "min_stdarg_gpr", "+=", "GPR2_REGNUM", ";", "max_stdarg_gpr", "+=", "GPR2_REGNUM", ";", "}", "if", "(", "s390_preserve_args_p", "&&", "crtl", "->", "args", ".", "info", ".", "gprs", ")", "{", "min_preserve_gpr", "=", "GPR2_REGNUM", ";", "max_preserve_gpr", "=", "MIN", "(", "GPR6_REGNUM", ",", "GPR2_REGNUM", "+", "crtl", "->", "args", ".", "info", ".", "gprs", "-", "1", ")", ";", "}", "min_gpr", "=", "MIN", "(", "min_stdarg_gpr", ",", "min_preserve_gpr", ")", ";", "max_gpr", "=", "MAX", "(", "max_stdarg_gpr", ",", "max_preserve_gpr", ")", ";", "if", "(", "max_gpr", "==", "-", "1", ")", "return", ";", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "GPR6_REGNUM", ")", ")", "&&", "min_gpr", "<=", "GPR6_REGNUM", "&&", "max_gpr", ">=", "GPR6_REGNUM", ")", "{", "if", "(", "cfun_frame_layout", ".", "first_restore_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "first_restore_gpr", ">", "GPR6_REGNUM", ")", "cfun_frame_layout", ".", "first_restore_gpr", "=", "GPR6_REGNUM", ";", "if", "(", "cfun_frame_layout", ".", "last_restore_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "last_restore_gpr", "<", "GPR6_REGNUM", ")", "cfun_frame_layout", ".", "last_restore_gpr", "=", "GPR6_REGNUM", ";", "}", "if", "(", "cfun_frame_layout", ".", "first_save_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "first_save_gpr", ">", "min_gpr", ")", "cfun_frame_layout", ".", "first_save_gpr", "=", "min_gpr", ";", "if", "(", "cfun_frame_layout", ".", "last_save_gpr", "==", "-", "1", "||", "cfun_frame_layout", ".", "last_save_gpr", "<", "max_gpr", ")", "cfun_frame_layout", ".", "last_save_gpr", "=", "max_gpr", ";", "for", "(", "i", "=", "min_gpr", ";", "i", "<=", "max_gpr", ";", "i", "++", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "}", "</s>" ]

[ "Reserve", "the", "GPR", "save", "slots", "for", "GPRs", "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", "1", "1", "1" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "!", "TM", ".", "getXCOFFTracebackTable", "(", ")", ")", "return", ";", "emitTracebackTable", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "AArch64PostLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "assert", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Legalized", ")", "&&", "\"Expected a legalized function?\"", ")", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AArch64PostLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "GISelCSEAnalysisWrapper", "&", "Wrapper", "=", "getAnalysis", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ".", "getCSEWrapper", "(", ")", ";", "auto", "*", "CSEInfo", "=", "&", "Wrapper", ".", "get", "(", "TPC", "->", "getCSEConfig", "(", ")", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "CSEInfo", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Expected a legalized function?\"", "AArch64" ]

[]

[ "<s>", "static", "void", "init_alignment_context", "(", "struct", "alignment_context", "*", "ac", ",", "rtx", "mem", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "byteoffset", "=", "NULL_RTX", ";", "bool", "aligned", "=", "(", "MEM_ALIGN", "(", "mem", ")", ">=", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "if", "(", "aligned", ")", "ac", "->", "memsi", "=", "adjust_address", "(", "mem", ",", "SImode", ",", "0", ")", ";", "else", "{", "rtx", "addr", ",", "align", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "GET_MODE_SIZE", "(", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "ac", "->", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "set_mem_alias_set", "(", "ac", "->", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "set_mem_align", "(", "ac", "->", "memsi", ",", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "byteoffset", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "1", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "ac", "->", "shift", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "!", "aligned", ")", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MINUS", ",", "ac", "->", "shift", ",", "byteoffset", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "{", "if", "(", "aligned", ")", "ac", "->", "shift", "=", "NULL_RTX", ";", "else", "ac", "->", "shift", "=", "byteoffset", ";", "}", "if", "(", "ac", "->", "shift", "!=", "NULL_RTX", ")", "{", "gcc_assert", "(", "exact_log2", "(", "BITS_PER_UNIT", ")", ">=", "0", ")", ";", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "ac", "->", "shift", ",", "GEN_INT", "(", "exact_log2", "(", "BITS_PER_UNIT", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "ac", "->", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "ac", "->", "modemask", "=", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ";", "ac", "->", "modemaski", "=", "expand_simple_unop", "(", "SImode", ",", "NOT", ",", "ac", "->", "modemask", ",", "NULL_RTX", ",", "1", ")", ";", "}", "</s>" ]

[ "Initialize", "structure", "AC", "for", "word", "access", "to", "HI", "and", "QI", "mode", "memory", "." ]

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

[]

[ "<s>", "static", "tree", "aarch64_embedded_comparison_type", "(", "stmt_vec_info", "stmt_info", ")", "{", "if", "(", "auto", "*", "assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt_info", "->", "stmt", ")", ")", "if", "(", "gimple_assign_rhs_code", "(", "assign", ")", "==", "COND_EXPR", ")", "{", "tree", "cond", "=", "gimple_assign_rhs1", "(", "assign", ")", ";", "if", "(", "COMPARISON_CLASS_P", "(", "cond", ")", ")", "return", "TREE_TYPE", "(", "TREE_OPERAND", "(", "cond", ",", "0", ")", ")", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "If", "STMT_INFO", "is", "a", "COND_EXPR", "that", "includes", "an", "embedded", "comparison", ",", "return", "the", "scalar", "type", "of", "the", "values", "being", "compared", ".", "Return", "null", "otherwise", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "EVEX2VEX_DESC", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "AArch64Subtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "nios2_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "cur_tree", ";", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "cur_tree", "=", "nios2_valid_target_attribute_tree", "(", "args", ")", ";", "if", "(", "!", "cur_tree", ")", "return", "false", ";", "}", "target_option_current_node", "=", "cur_tree", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "FPU", "custom", "code", "option", "state", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "nios2" ]

[]

[ "<s>", "void", "machopic_output_stub", "(", "FILE", "*", "file", ",", "const", "char", "*", "symb", ",", "const", "char", "*", "stub", ")", "{", "unsigned", "int", "length", ";", "char", "*", "symbol_name", ",", "*", "lazy_ptr_name", ";", "char", "*", "local_label_0", ";", "static", "int", "label", "=", "0", ";", "symb", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "symb", ")", ";", "length", "=", "strlen", "(", "symb", ")", ";", "symbol_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_SYMBOL_NAME_FOR_SYMBOL", "(", "symbol_name", ",", "symb", ",", "length", ")", ";", "lazy_ptr_name", "=", "XALLOCAVEC", "(", "char", ",", "length", "+", "32", ")", ";", "GEN_LAZY_PTR_NAME_FOR_SYMBOL", "(", "lazy_ptr_name", ",", "symb", ",", "length", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "switch_to_section", "(", "darwin_sections", "[", "machopic_picsymbol_stub1_section", "]", ")", ";", "else", "switch_to_section", "(", "darwin_sections", "[", "machopic_symbol_stub1_section", "]", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "{", "fprintf", "(", "file", ",", "\"\\t.align 5\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "label", "++", ";", "local_label_0", "=", "XALLOCAVEC", "(", "char", ",", "sizeof", "(", "\"\\\"L00000000000$spb\\\"\"", ")", ")", ";", "sprintf", "(", "local_label_0", ",", "\"\\\"L%011d$spb\\\"\"", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tmflr r0\\n\"", ")", ";", "if", "(", "TARGET_LINK_STACK", ")", "{", "char", "name", "[", "32", "]", ";", "get_ppc476_thunk_name", "(", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\\tmflr r11\\n\"", ",", "local_label_0", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\tbcl 20,31,%s\\n\"", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\\tmflr r11\\n\"", ",", "local_label_0", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\taddis r11,r11,ha16(%s-%s)\\n\"", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtlr r0\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s r12,lo16(%s-%s)(r11)\\n\"", ",", "(", "TARGET_64BIT", "?", "\"ldu\"", ":", "\"lwzu\"", ")", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtctr r12\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tbctr\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\t.align 4\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tlis r11,ha16(%s)\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s r12,lo16(%s)(r11)\\n\"", ",", "(", "TARGET_64BIT", "?", "\"ldu\"", ":", "\"lwzu\"", ")", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tmtctr r12\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tbctr\\n\"", ")", ";", "}", "switch_to_section", "(", "darwin_sections", "[", "machopic_lazy_symbol_ptr_section", "]", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "\"%sdyld_stub_binding_helper\\n\"", ",", "(", "TARGET_64BIT", "?", "DOUBLE_INT_ASM_OP", ":", "\"\\t.long\\t\"", ")", ")", ";", "}", "</s>" ]

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

[ "rs6000", "0", "32", "32", "2", "2", "\"\\t.align 5\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\\"L00000000000$spb\\\"\"", "\"\\\"L%011d$spb\\\"\"", "\"\\tmflr r0\\n\"", "32", "\"\\tbl %s\\n\"", "\"%s:\\n\\tmflr r11\\n\"", "\"\\tbcl 20,31,%s\\n\"", "\"%s:\\n\\tmflr r11\\n\"", "\"\\taddis r11,r11,ha16(%s-%s)\\n\"", "\"\\tmtlr r0\\n\"", "\"\\t%s r12,lo16(%s-%s)(r11)\\n\"", "\"ldu\"", "\"lwzu\"", "\"\\tmtctr r12\\n\"", "\"\\tbctr\\n\"", "\"\\t.align 4\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\tlis r11,ha16(%s)\\n\"", "\"\\t%s r12,lo16(%s)(r11)\\n\"", "\"ldu\"", "\"lwzu\"", "\"\\tmtctr r12\\n\"", "\"\\tbctr\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"%sdyld_stub_binding_helper\\n\"", "\"\\t.long\\t\"" ]

[]

[ "<s>", "static", "inline", "int", "extract_17", "(", "unsigned", "word", ")", "{", "return", "sign_extend", "(", "GET_FIELD", "(", "word", ",", "19", ",", "28", ")", "|", "GET_FIELD", "(", "word", ",", "29", ",", "29", ")", "<<", "10", "|", "GET_FIELD", "(", "word", ",", "11", ",", "15", ")", "<<", "11", "|", "(", "word", "&", "0x1", ")", "<<", "16", ",", "17", ")", ";", "}", "</s>" ]

[ "Extract", "a", "17-bit", "signed", "constant", "from", "branch", "instructions", "." ]

[ "pa", "19", "28", "29", "29", "10", "11", "15", "11", "0x1", "16", "17" ]

[]

[ "<s>", "unsigned", "mmix_local_alignment", "(", "tree", "type", "ATTRIBUTE_UNUSED", ",", "unsigned", "basic_align", ")", "{", "if", "(", "basic_align", "<", "32", ")", "return", "32", ";", "return", "basic_align", ";", "}", "</s>" ]

[ "LOCAL_ALIGNMENT", "." ]

[ "mmix", "32", "32" ]

[]

[ "<s>", "bool", "mep_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

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

[ "mep" ]

[]

[ "<s>", "const", "unsigned", "*", "PIC16RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "0" ]

[]

[ "<s>", "bool", "fr30_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ";", "}", "</s>" ]

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

[ "fr30" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "PerformTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt16", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "0xFFFF" ]

[]

[ "<s>", "void", "TOYPassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_integer_scalar_type", "(", "unsigned", "int", "argno", ")", "{", "tree", "actual", "=", "get_argument_type", "(", "argno", ")", ";", "if", "(", "actual", "==", "error_mark_node", ")", "return", "NUM_TYPE_SUFFIXES", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "actual", ")", ")", "{", "bool", "uns_p", "=", "TYPE_UNSIGNED", "(", "actual", ")", ";", "if", "(", "TYPE_PRECISION", "(", "actual", ")", "<", "32", ")", "return", "TYPE_SUFFIX_s32", ";", "if", "(", "TYPE_PRECISION", "(", "actual", ")", "==", "32", ")", "return", "uns_p", "?", "TYPE_SUFFIX_u32", ":", "TYPE_SUFFIX_s32", ";", "if", "(", "TYPE_PRECISION", "(", "actual", ")", "==", "64", ")", "return", "uns_p", "?", "TYPE_SUFFIX_u64", ":", "TYPE_SUFFIX_s64", ";", "}", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which expects\"", "\" a 32-bit or 64-bit integer type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "32-bit", "or", "64-bit", "scalar", "integer", "type", ".", "Return", "the", "associated", "type", "suffix", "on", "success", ",", "otherwise", "report", "an", "error", "and", "return", "NUM_TYPE_SUFFIXES", "." ]

[ "aarch64", "32", "32", "64", "\"passing %qT to argument %d of %qE, which expects\"", "\" a 32-bit or 64-bit integer type\"", "1" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__memory_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_size\"", ")", "==", "0", ")", "{", "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__tls_base\"", ")", "==", "0", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "\"__memory_base\"", "0", "\"__table_base\"", "0", "\"__tls_size\"", "0", "\"__stack_pointer\"", "0", "\"__tls_base\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "bool", "emitSymbolAttribute", "(", "MCSymbol", "*", "Symbol", ",", "MCSymbolAttr", "Attribute", ")", "override", "{", "bool", "Val", "=", "MCELFStreamer", "::", "emitSymbolAttribute", "(", "Symbol", ",", "Attribute", ")", ";", "if", "(", "!", "IsThumb", ")", "return", "Val", ";", "unsigned", "Type", "=", "cast", "<", "MCSymbolELF", ">", "(", "Symbol", ")", "->", "getType", "(", ")", ";", "if", "(", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", "&&", "Symbol", "->", "isDefined", "(", ")", ")", "getAssembler", "(", ")", ".", "setIsThumbFunc", "(", "Symbol", ")", ";", "return", "Val", ";", "}", "</s>" ]

[ "Add", "the", "given", "Attribute", "to", "Symbol", "." ]

[ "ARM" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "getSize", "(", ")", ")", "return", "MCID", ".", "getSize", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleLength", "(", "MI", ")", ";", "case", "ARM", "::", "MOVi16_ga_pcrel", ":", "case", "ARM", "::", "MOVTi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVTi16_ga_pcrel", ":", "return", "4", ";", "case", "ARM", "::", "MOVi32imm", ":", "case", "ARM", "::", "t2MOVi32imm", ":", "return", "8", ";", "case", "ARM", "::", "CONSTPOOL_ENTRY", ":", "case", "ARM", "::", "JUMPTABLE_INSTS", ":", "case", "ARM", "::", "JUMPTABLE_ADDRS", ":", "case", "ARM", "::", "JUMPTABLE_TBB", ":", "case", "ARM", "::", "JUMPTABLE_TBH", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "case", "ARM", "::", "Int_eh_sjlj_longjmp", ":", "return", "16", ";", "case", "ARM", "::", "tInt_eh_sjlj_longjmp", ":", "return", "10", ";", "case", "ARM", "::", "tInt_WIN_eh_sjlj_longjmp", ":", "return", "12", ";", "case", "ARM", "::", "Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "Int_eh_sjlj_setjmp_nofp", ":", "return", "20", ";", "case", "ARM", "::", "tInt_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp_nofp", ":", "return", "12", ";", "case", "ARM", "::", "SPACE", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "case", "ARM", "::", "INLINEASM", ":", "case", "ARM", "::", "INLINEASM_BR", ":", "{", "unsigned", "Size", "=", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "if", "(", "!", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ")", "Size", "=", "alignTo", "(", "Size", ",", "4", ")", ";", "return", "Size", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARM::MOVi16_ga_pcrel", "ARM::MOVTi16_ga_pcrel", "ARM::t2MOVi16_ga_pcrel", "ARM::t2MOVTi16_ga_pcrel", "4", "ARM::MOVi32imm", "ARM::t2MOVi32imm", "8", "ARM::CONSTPOOL_ENTRY", "ARM::JUMPTABLE_INSTS", "ARM::JUMPTABLE_ADDRS", "ARM::JUMPTABLE_TBB", "ARM::JUMPTABLE_TBH", "2", "ARM::Int_eh_sjlj_longjmp", "16", "ARM::tInt_eh_sjlj_longjmp", "10", "ARM::tInt_WIN_eh_sjlj_longjmp", "12", "ARM::Int_eh_sjlj_setjmp", "ARM::Int_eh_sjlj_setjmp_nofp", "20", "ARM::tInt_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp_nofp", "12", "ARM::SPACE", "1", "ARM::INLINEASM", "ARM::INLINEASM_BR", "0", "ARM", "4" ]

[]

[ "<s>", "bool", "JVMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "JVM", "JVM" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'s'", ":", "case", "'r'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "case", "64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "case", "128", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "case", "256", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_256RegClass", ")", ";", "case", "512", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "SReg_512RegClass", ")", ";", "}", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "32", ":", "case", "16", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "case", "64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_64RegClass", ")", ";", "case", "96", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_96RegClass", ")", ";", "case", "128", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_128RegClass", ")", ";", "case", "256", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_256RegClass", ")", ";", "case", "512", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AMDGPU", "::", "VReg_512RegClass", ")", ";", "}", "}", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "uint32_t", "Idx", ";", "bool", "Failed", "=", "Constraint", ".", "substr", "(", "2", ")", ".", "getAsInteger", "(", "10", ",", "Idx", ")", ";", "if", "(", "!", "Failed", "&&", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "0", "0U", "32", "16", "0U", "AMDGPU::SReg_32_XM0RegClass", "64", "0U", "AMDGPU::SGPR_64RegClass", "128", "0U", "AMDGPU::SReg_128RegClass", "256", "0U", "AMDGPU::SReg_256RegClass", "512", "0U", "AMDGPU::SReg_512RegClass", "0U", "32", "16", "0U", "AMDGPU::VGPR_32RegClass", "64", "0U", "AMDGPU::VReg_64RegClass", "96", "0U", "AMDGPU::VReg_96RegClass", "128", "0U", "AMDGPU::VReg_128RegClass", "256", "0U", "AMDGPU::VReg_256RegClass", "512", "0U", "AMDGPU::VReg_512RegClass", "1", "1", "AMDGPU::VGPR_32RegClass", "1", "AMDGPU::SGPR_32RegClass", "2", "10" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "FMAX", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "BREV", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addILPOpts", "(", ")", "{", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "unsigned", "SNESTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", ";", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"X\"", ",", "SNES", "::", "X", ")", ".", "Case", "(", "\"Y\"", ",", "SNES", "::", "Y", ")", ".", "Case", "(", "\"A\"", ",", "SNES", "::", "A", ")", ".", "Default", "(", "0", ")", ";", "}", "else", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"X\"", ",", "SNES", "::", "X", ")", ".", "Case", "(", "\"Y\"", ",", "SNES", "::", "Y", ")", ".", "Case", "(", "\"A\"", ",", "SNES", "::", "A", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "MVT::i8", "\"X\"", "SNES::X", "\"Y\"", "SNES::Y", "\"A\"", "SNES::A", "0", "\"X\"", "SNES::X", "\"Y\"", "SNES::Y", "\"A\"", "SNES::A", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "const", "MCSection", "*", "SystemZMCAsmInfo", "::", "getNonexecutableStackSection", "(", "MCContext", "&", "Ctx", ")", "const", "{", "return", "Ctx", ".", "getELFSection", "(", "\".note.GNU-stack\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "SystemZ", "SystemZ", "\".note.GNU-stack\"", "0" ]

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "II", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "JTI", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "do", "{", "DOUT", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "%", "4", "!=", "0", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0x01000000", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Sparc", "4", "0", "4", "0", "0x01000000" ]

[]

[ "<s>", "SDValue", "OpenRISCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_OpenRISC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "ISD::InputArg", "16", "OpenRISC", "0", "1", "2", "0" ]

[]

[ "<s>", "SDNode", "*", "TeeRISCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "const", "std", "::", "string", "&", "ARMToARMStub", "::", "name", "(", ")", "const", "{", "return", "m_Name", ";", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "tree", "aarch64_get_attributes", "(", "unsigned", "int", "f", ",", "machine_mode", "mode", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "if", "(", "!", "aarch64_modifies_global_state_p", "(", "f", ",", "mode", ")", ")", "{", "if", "(", "aarch64_reads_global_state_p", "(", "f", ",", "mode", ")", ")", "attrs", "=", "aarch64_add_attribute", "(", "\"pure\"", ",", "attrs", ")", ";", "else", "attrs", "=", "aarch64_add_attribute", "(", "\"const\"", ",", "attrs", ")", ";", "}", "if", "(", "!", "flag_non_call_exceptions", "||", "!", "aarch64_could_trap_p", "(", "f", ",", "mode", ")", ")", "attrs", "=", "aarch64_add_attribute", "(", "\"nothrow\"", ",", "attrs", ")", ";", "return", "aarch64_add_attribute", "(", "\"leaf\"", ",", "attrs", ")", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "function", "attributes", "." ]

[ "aarch64", "\"pure\"", "\"const\"", "\"nothrow\"", "\"leaf\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Promote Constant\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Promote Constant\"" ]

[]

[ "<s>", "void", "thumb1_gen_const_int_rtl", "(", "rtx", "dst", ",", "HOST_WIDE_INT", "op1", ")", "{", "thumb1_const_rtl", "t", "(", "dst", ")", ";", "thumb1_gen_const_int_1", "(", "t", ",", "op1", ")", ";", "}", "</s>" ]

[ "Proxies", "for", "thumb1.md", ",", "since", "the", "thumb1_const_print", "and", "thumb1_const_rtl", "classes", "are", "not", "exported", "." ]

[ "arm" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "IID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ")", "{", "static", "const", "CostTblEntry", "XOPCostTbl", "[", "]", "=", "{", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v4i64", ",", "4", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v8i32", ",", "4", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v16i16", ",", "4", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v32i8", ",", "4", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v2i64", ",", "1", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "i64", ",", "3", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "i32", ",", "3", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "i16", ",", "3", "}", ",", "{", "ISD", "::", "BITREVERSE", ",", "MVT", "::", "i8", ",", "3", "}", "}", ";", "unsigned", "ISD", "=", "ISD", "::", "DELETED_NODE", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "bitreverse", ":", "ISD", "=", "ISD", "::", "BITREVERSE", ";", "break", ";", "}", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "MVT", "MTy", "=", "LT", ".", "second", ";", "if", "(", "ST", "->", "hasXOP", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "XOPCostTbl", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "IID", ",", "RetTy", ",", "Tys", ",", "FMF", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "X86", "X86", "Intrinsic::ID", "ISD::BITREVERSE", "MVT::v4i64", "4", "ISD::BITREVERSE", "MVT::v8i32", "4", "ISD::BITREVERSE", "MVT::v16i16", "4", "ISD::BITREVERSE", "MVT::v32i8", "4", "ISD::BITREVERSE", "MVT::v2i64", "1", "ISD::BITREVERSE", "MVT::v4i32", "1", "ISD::BITREVERSE", "MVT::v8i16", "1", "ISD::BITREVERSE", "MVT::v16i8", "1", "ISD::BITREVERSE", "MVT::i64", "3", "ISD::BITREVERSE", "MVT::i32", "3", "ISD::BITREVERSE", "MVT::i16", "3", "ISD::BITREVERSE", "MVT::i8", "3", "ISD::DELETED_NODE", "Intrinsic::bitreverse", "ISD::BITREVERSE" ]

[]

[ "<s>", "unsigned", "NVPTXTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ")", "{", "std", "::", "pair", "<", "unsigned", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "if", "(", "LT", ".", "second", ".", "SimpleTy", "==", "MVT", "::", "i64", ")", "return", "2", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "MVT::i64", "2" ]

[]

[ "<s>", "AVRTargetLowering", "::", "ConstraintType", "AVRTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'b'", ":", "case", "'d'", ":", "case", "'l'", ":", "case", "'e'", ":", "case", "'q'", ":", "case", "'r'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "case", "'x'", ":", "case", "'X'", ":", "case", "'y'", ":", "case", "'Y'", ":", "case", "'z'", ":", "case", "'Z'", ":", "return", "C_Register", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'G'", ":", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "case", "'R'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "AVR", "AVR", "AVR", "1", "0" ]

[]

[ "<s>", "void", "Nios2PassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "Nios2", "Nios2" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSContiki", "(", ")", ")", "return", "getDefaultSafeStackPointerLocation", "(", "IRB", ",", "false", ")", ";", "if", "(", "!", "Subtarget", ".", "isTargetAndroid", "(", ")", ")", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "unsigned", "AddressSpace", ",", "Offset", ";", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x48", ":", "0x24", ";", "AddressSpace", "=", "getAddressSpace", "(", ")", ";", "return", "ConstantExpr", "::", "getIntToPtr", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "IRB", ".", "getContext", "(", ")", ")", ",", "Offset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "AddressSpace", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "X86", "X86", "0x48", "0x24" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "I", ":", "Converters", ")", "delete", "I", ".", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"missing feature\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "R600", "\"missing feature\"", "\"unrecognized instruction mnemonic\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "void", "expand_block_move_2", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "src", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "2", ";", "emit_library_call", "(", "wrd_memcpy_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dst_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "1", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "src", "=", "replace_equiv_address_nv", "(", "src", ",", "src_reg", ")", ";", "bytes", "-=", "rem", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "adjust_address_nv", "(", "src", ",", "QImode", ",", "bytes", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "move", "BYTES_RTX", "bytes", "from", "SRC", "with", "address", "SRC_REG", "to", "DST", "with", "address", "DST_REG", "in", "2-bytes", "chunks", "." ]

[ "visium", "2", "1", "0" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "Z80MachineFunctionInfo", "*", "Z80FI", "=", "MF", ".", "getInfo", "<", "Z80MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Z80", ")", ";", "assert", "(", "!", "isVarArg", "&&", "\"Varargs not supported yet!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "SDValue", "ArgValue", ";", "unsigned", "VReg", ";", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i8", ":", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Z80", "::", "GR8RegClass", ")", ";", "MRI", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "case", "MVT", "::", "i16", ":", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Z80", "::", "GR16RegClass", ")", ";", "MRI", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "Z80FI", "->", "setNeedFP", "(", ")", ";", "SDValue", "InVal", ";", "unsigned", "Size", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "if", "(", "Size", ">", "2", ")", "errs", "(", ")", "<<", "\"LowerFormalArguments unhandled argument type: \"", "<<", "EVT", "(", "VA", ".", "getLocVT", "(", ")", ")", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "Size", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "InVal", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "InVals", ".", "push_back", "(", "InVal", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "ISD::InputArg", "Z80", "Z80", "Z80", "16", "Z80", "\"Varargs not supported yet!\"", "0", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "0", "MVT::i8", "Z80::GR8RegClass", "MVT::i16", "Z80::GR16RegClass", "Z80", "2", "\"LowerFormalArguments unhandled argument type: \"", "\"\\n\"", "MVT::i16", "0" ]

[]

[ "<s>", "enum", "machine_mode", "s390_tm_ccmode", "(", "rtx", "op1", ",", "rtx", "op2", ",", "bool", "mixed", ")", "{", "int", "bit0", ",", "bit1", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", "||", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", ")", "return", "VOIDmode", ";", "if", "(", "INTVAL", "(", "op2", ")", "==", "0", ")", "return", "CCTmode", ";", "if", "(", "INTVAL", "(", "op2", ")", "==", "INTVAL", "(", "op1", ")", ")", "return", "CCT3mode", ";", "if", "(", "mixed", ")", "{", "bit1", "=", "exact_log2", "(", "INTVAL", "(", "op2", ")", ")", ";", "bit0", "=", "exact_log2", "(", "INTVAL", "(", "op1", ")", "^", "INTVAL", "(", "op2", ")", ")", ";", "if", "(", "bit0", "!=", "-", "1", "&&", "bit1", "!=", "-", "1", ")", "return", "bit0", ">", "bit1", "?", "CCT1mode", ":", "CCT2mode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "If", "a", "test-under-mask", "instruction", "can", "be", "used", "to", "implement", "(", "compare", "(", "and", "...", "OP1", ")", "OP2", ")", ",", "return", "the", "CC", "mode", "required", "to", "do", "that", ".", "Otherwise", ",", "return", "VOIDmode", ".", "MIXED", "is", "true", "if", "the", "instruction", "can", "distinguish", "between", "CC1", "and", "CC2", "for", "mixed", "selected", "bits", "(", "TMxx", ")", ",", "it", "is", "false", "if", "the", "instruction", "can", "not", "(", "TM", ")", "." ]

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

[]

[ "<s>", "bool", "X86WinAllocaExpander", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasWinAlloca", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "StackPtr", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "SlotSize", "=", "TRI", "->", "getSlotSize", "(", ")", ";", "StackProbeSize", "=", "4096", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"stack-probe-size\"", ")", ")", "{", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"stack-probe-size\"", ")", ".", "getValueAsString", "(", ")", ".", "getAsInteger", "(", "0", ",", "StackProbeSize", ")", ";", "}", "LoweringMap", "Lowerings", ";", "computeLowerings", "(", "MF", ",", "Lowerings", ")", ";", "for", "(", "auto", "&", "P", ":", "Lowerings", ")", "lower", "(", "P", ".", "first", ",", "P", ".", "second", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "4096", "\"stack-probe-size\"", "\"stack-probe-size\"", "0" ]

[]

[ "<s>", "void", "order_regs_for_local_alloc", "(", "void", ")", "{", "unsigned", "int", "i", ";", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "order_1", ":", "TARGET_ORDER_2", "?", "order_2", ":", "order_0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0" ]

[]

[ "<s>", "SparcTargetLowering", "::", "ConstraintType", "SparcTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "Sparc", "Sparc", "Sparc", "1", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", "->", "getCallingConv", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "getSubtarget", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "!", "CallerPreserved", ")", "return", "false", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "{", "if", "(", "canGuaranteeTCO", "(", "CalleeCC", ")", "&&", "CCMatch", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "IsVarArg", ")", "return", "false", ";", "for", "(", "const", "Argument", "&", "Arg", ":", "CallerF", "->", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasByValAttr", "(", ")", ")", "return", "false", ";", "}", "LLVMContext", "&", "Ctx", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "if", "(", "!", "CCState", "::", "resultsCompatible", "(", "CalleeCC", ",", "CallerCC", ",", "MF", ",", "Ctx", ",", "Ins", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "IsVarArg", ")", ",", "CCAssignFnForCall", "(", "CallerCC", ",", "IsVarArg", ")", ")", ")", "return", "false", ";", "if", "(", "!", "CCMatch", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "if", "(", "Outs", ".", "empty", "(", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "Ctx", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "IsVarArg", ")", ")", ";", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ">", "FuncInfo", "->", "getBytesInStackArgArea", "(", ")", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "parametersInCSRMatch", "(", "MRI", ",", "CallerPreserved", ",", "ArgLocs", ",", "OutVals", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "ISD::OutputArg", "ISD::InputArg", "SI", "16", "SI", "SI" ]

[]

[ "<s>", "bool", "aarch64_pad_reg_upward", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "first", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", "&&", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "size", "<", "2", "*", "UNITS_PER_WORD", ")", "{", "pure_scalable_type_info", "pst_info", ";", "if", "(", "pst_info", ".", "analyze_registers", "(", "type", ")", ")", "return", "false", ";", "return", "true", ";", "}", "}", "return", "!", "BYTES_BIG_ENDIAN", ";", "}", "</s>" ]

[ "Similarly", ",", "for", "use", "by", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "FIRST", ")", ".", "It", "specifies", "padding", "for", "the", "last", "(", "may", "also", "be", "the", "only", ")", "element", "of", "a", "block", "move", "between", "registers", "and", "memory", ".", "If", "assuming", "the", "block", "is", "in", "the", "memory", ",", "padding", "upward", "means", "that", "the", "last", "element", "is", "padded", "after", "its", "highest", "significant", "byte", ",", "while", "in", "downward", "padding", ",", "the", "last", "element", "is", "padded", "at", "the", "its", "least", "significant", "byte", "side", ".", "Small", "aggregates", "and", "small", "complex", "types", "are", "always", "padded", "upwards", ".", "We", "do", "n't", "need", "to", "worry", "about", "homogeneous", "floating-point", "or", "short-vector", "aggregates", ";", "their", "move", "is", "not", "affected", "by", "the", "padding", "direction", "determined", "here", ".", "Regardless", "of", "endianness", ",", "each", "element", "of", "such", "an", "aggregate", "is", "put", "in", "the", "least", "significant", "bits", "of", "a", "fp/simd", "register", ".", "Return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ",", "and", "return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "(", "Fn", ".", "getRegInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "MI", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "findCommutedOpIndices", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "assert", "(", "!", "MI", ".", "isBundle", "(", ")", "&&", "\"MOSInstrInfo::findCommutedOpIndices() can't handle bundles\"", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "unsigned", "CommutableOpIdx1", ",", "CommutableOpIdx2", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode; don't know how to commute.\"", ")", ";", "case", "MOS", "::", "ADCImag8", ":", "CommutableOpIdx1", "=", "3", ";", "CommutableOpIdx2", "=", "4", ";", "break", ";", "case", "MOS", "::", "ANDImag8", ":", "case", "MOS", "::", "EORImag8", ":", "case", "MOS", "::", "ORAImag8", ":", "CommutableOpIdx1", "=", "1", ";", "CommutableOpIdx2", "=", "2", ";", "break", ";", "}", "if", "(", "!", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "CommutableOpIdx1", ",", "CommutableOpIdx2", ")", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "SrcOpIdx1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "SrcOpIdx2", ")", ".", "isReg", "(", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "MOS", "MOS", "\"MOSInstrInfo::findCommutedOpIndices() can't handle bundles\"", "\"Unexpected opcode; don't know how to commute.\"", "MOS::ADCImag8", "3", "4", "MOS::ANDImag8", "MOS::EORImag8", "MOS::ORAImag8", "1", "2" ]

[]

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

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

[ "ARM", "ARM", "\"__security_check_cookie\"" ]

[]

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

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

[ "SHUXI", "SHUXI" ]

[]