Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "CSKYInstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "if", "(", "Opt", "==", "\"no-aliases\"", ")", "{", "NoAliases", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"numeric\"", ")", "{", "ArchRegNames", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "." ]

[ "CSKY", "CSKY", "\"no-aliases\"", "\"numeric\"" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "HexagonISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "HexagonISD", "::", "ALLOCA", ":", "return", "\"HexagonISD::ALLOCA\"", ";", "case", "HexagonISD", "::", "AT_GOT", ":", "return", "\"HexagonISD::AT_GOT\"", ";", "case", "HexagonISD", "::", "AT_PCREL", ":", "return", "\"HexagonISD::AT_PCREL\"", ";", "case", "HexagonISD", "::", "BARRIER", ":", "return", "\"HexagonISD::BARRIER\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "CALLnr", ":", "return", "\"HexagonISD::CALLnr\"", ";", "case", "HexagonISD", "::", "CALLR", ":", "return", "\"HexagonISD::CALLR\"", ";", "case", "HexagonISD", "::", "COMBINE", ":", "return", "\"HexagonISD::COMBINE\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CP", ":", "return", "\"HexagonISD::CP\"", ";", "case", "HexagonISD", "::", "DCFETCH", ":", "return", "\"HexagonISD::DCFETCH\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "case", "HexagonISD", "::", "EXTRACTU", ":", "return", "\"HexagonISD::EXTRACTU\"", ";", "case", "HexagonISD", "::", "EXTRACTURP", ":", "return", "\"HexagonISD::EXTRACTURP\"", ";", "case", "HexagonISD", "::", "INSERT", ":", "return", "\"HexagonISD::INSERT\"", ";", "case", "HexagonISD", "::", "INSERTRP", ":", "return", "\"HexagonISD::INSERTRP\"", ";", "case", "HexagonISD", "::", "JT", ":", "return", "\"HexagonISD::JT\"", ";", "case", "HexagonISD", "::", "PACKHL", ":", "return", "\"HexagonISD::PACKHL\"", ";", "case", "HexagonISD", "::", "POPCOUNT", ":", "return", "\"HexagonISD::POPCOUNT\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "SHUFFEB", ":", "return", "\"HexagonISD::SHUFFEB\"", ";", "case", "HexagonISD", "::", "SHUFFEH", ":", "return", "\"HexagonISD::SHUFFEH\"", ";", "case", "HexagonISD", "::", "SHUFFOB", ":", "return", "\"HexagonISD::SHUFFOB\"", ";", "case", "HexagonISD", "::", "SHUFFOH", ":", "return", "\"HexagonISD::SHUFFOH\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "VCMPBEQ", ":", "return", "\"HexagonISD::VCMPBEQ\"", ";", "case", "HexagonISD", "::", "VCMPBGT", ":", "return", "\"HexagonISD::VCMPBGT\"", ";", "case", "HexagonISD", "::", "VCMPBGTU", ":", "return", "\"HexagonISD::VCMPBGTU\"", ";", "case", "HexagonISD", "::", "VCMPHEQ", ":", "return", "\"HexagonISD::VCMPHEQ\"", ";", "case", "HexagonISD", "::", "VCMPHGT", ":", "return", "\"HexagonISD::VCMPHGT\"", ";", "case", "HexagonISD", "::", "VCMPHGTU", ":", "return", "\"HexagonISD::VCMPHGTU\"", ";", "case", "HexagonISD", "::", "VCMPWEQ", ":", "return", "\"HexagonISD::VCMPWEQ\"", ";", "case", "HexagonISD", "::", "VCMPWGT", ":", "return", "\"HexagonISD::VCMPWGT\"", ";", "case", "HexagonISD", "::", "VCMPWGTU", ":", "return", "\"HexagonISD::VCMPWGTU\"", ";", "case", "HexagonISD", "::", "VCOMBINE", ":", "return", "\"HexagonISD::VCOMBINE\"", ";", "case", "HexagonISD", "::", "VPACK", ":", "return", "\"HexagonISD::VPACK\"", ";", "case", "HexagonISD", "::", "VSHLH", ":", "return", "\"HexagonISD::VSHLH\"", ";", "case", "HexagonISD", "::", "VSHLW", ":", "return", "\"HexagonISD::VSHLW\"", ";", "case", "HexagonISD", "::", "VSPLATB", ":", "return", "\"HexagonISD::VSPLTB\"", ";", "case", "HexagonISD", "::", "VSPLATH", ":", "return", "\"HexagonISD::VSPLATH\"", ";", "case", "HexagonISD", "::", "VSRAH", ":", "return", "\"HexagonISD::VSRAH\"", ";", "case", "HexagonISD", "::", "VSRAW", ":", "return", "\"HexagonISD::VSRAW\"", ";", "case", "HexagonISD", "::", "VSRLH", ":", "return", "\"HexagonISD::VSRLH\"", ";", "case", "HexagonISD", "::", "VSRLW", ":", "return", "\"HexagonISD::VSRLW\"", ";", "case", "HexagonISD", "::", "VSXTBH", ":", "return", "\"HexagonISD::VSXTBH\"", ";", "case", "HexagonISD", "::", "VSXTBW", ":", "return", "\"HexagonISD::VSXTBW\"", ";", "case", "HexagonISD", "::", "OP_END", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::NodeType", "HexagonISD::ALLOCA", "\"HexagonISD::ALLOCA\"", "HexagonISD::AT_GOT", "\"HexagonISD::AT_GOT\"", "HexagonISD::AT_PCREL", "\"HexagonISD::AT_PCREL\"", "HexagonISD::BARRIER", "\"HexagonISD::BARRIER\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::CALLnr", "\"HexagonISD::CALLnr\"", "HexagonISD::CALLR", "\"HexagonISD::CALLR\"", "HexagonISD::COMBINE", "\"HexagonISD::COMBINE\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CP", "\"HexagonISD::CP\"", "HexagonISD::DCFETCH", "\"HexagonISD::DCFETCH\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"", "HexagonISD::EXTRACTU", "\"HexagonISD::EXTRACTU\"", "HexagonISD::EXTRACTURP", "\"HexagonISD::EXTRACTURP\"", "HexagonISD::INSERT", "\"HexagonISD::INSERT\"", "HexagonISD::INSERTRP", "\"HexagonISD::INSERTRP\"", "HexagonISD::JT", "\"HexagonISD::JT\"", "HexagonISD::PACKHL", "\"HexagonISD::PACKHL\"", "HexagonISD::POPCOUNT", "\"HexagonISD::POPCOUNT\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::SHUFFEB", "\"HexagonISD::SHUFFEB\"", "HexagonISD::SHUFFEH", "\"HexagonISD::SHUFFEH\"", "HexagonISD::SHUFFOB", "\"HexagonISD::SHUFFOB\"", "HexagonISD::SHUFFOH", "\"HexagonISD::SHUFFOH\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::VCMPBEQ", "\"HexagonISD::VCMPBEQ\"", "HexagonISD::VCMPBGT", "\"HexagonISD::VCMPBGT\"", "HexagonISD::VCMPBGTU", "\"HexagonISD::VCMPBGTU\"", "HexagonISD::VCMPHEQ", "\"HexagonISD::VCMPHEQ\"", "HexagonISD::VCMPHGT", "\"HexagonISD::VCMPHGT\"", "HexagonISD::VCMPHGTU", "\"HexagonISD::VCMPHGTU\"", "HexagonISD::VCMPWEQ", "\"HexagonISD::VCMPWEQ\"", "HexagonISD::VCMPWGT", "\"HexagonISD::VCMPWGT\"", "HexagonISD::VCMPWGTU", "\"HexagonISD::VCMPWGTU\"", "HexagonISD::VCOMBINE", "\"HexagonISD::VCOMBINE\"", "HexagonISD::VPACK", "\"HexagonISD::VPACK\"", "HexagonISD::VSHLH", "\"HexagonISD::VSHLH\"", "HexagonISD::VSHLW", "\"HexagonISD::VSHLW\"", "HexagonISD::VSPLATB", "\"HexagonISD::VSPLTB\"", "HexagonISD::VSPLATH", "\"HexagonISD::VSPLATH\"", "HexagonISD::VSRAH", "\"HexagonISD::VSRAH\"", "HexagonISD::VSRAW", "\"HexagonISD::VSRAW\"", "HexagonISD::VSRLH", "\"HexagonISD::VSRLH\"", "HexagonISD::VSRLW", "\"HexagonISD::VSRLW\"", "HexagonISD::VSXTBH", "\"HexagonISD::VSXTBH\"", "HexagonISD::VSXTBW", "\"HexagonISD::VSXTBW\"", "HexagonISD::OP_END" ]

[]

[ "<s>", "void", "SPScope", "::", "merge", "(", "PredicatedBlock", "*", "b1", ",", "PredicatedBlock", "*", "b2", ")", "{", "b1", "->", "merge", "(", "b2", ")", ";", "Priv", "->", "replaceUseOfBlockWith", "(", "b2", ",", "b1", ")", ";", "std", "::", "function", "<", "bool", "(", "SPScope", "*", ")", ">", "recursiveErase", "=", "[", "&", "]", "(", "auto", "scope", ")", "{", "auto", "iter", "=", "std", "::", "find", "(", "scope", "->", "Priv", "->", "Blocks", ".", "begin", "(", ")", ",", "scope", "->", "Priv", "->", "Blocks", ".", "end", "(", ")", ",", "b2", ")", ";", "if", "(", "iter", "!=", "scope", "->", "Priv", "->", "Blocks", ".", "end", "(", ")", ")", "{", "scope", "->", "Priv", "->", "Blocks", ".", "erase", "(", "iter", ")", ";", "return", "true", ";", "}", "else", "{", "for", "(", "auto", "subscope", ":", "scope", "->", "Priv", "->", "Subscopes", ")", "{", "if", "(", "recursiveErase", "(", "subscope", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "}", ";", "auto", "erased", "=", "recursiveErase", "(", "this", ")", ";", "assert", "(", "erased", "&&", "\"Block not in scope tree\\n\"", ")", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "Patmos", "\"Block not in scope tree\\n\"" ]

[]

[ "<s>", "unsigned", "int", "pass_s390_early_mach", "::", "execute", "(", "function", "*", "fun", ")", "{", "rtx_insn", "*", "insn", ";", "s390_optimize_nonescaping_tx", "(", ")", ";", "s390_register_info", "(", ")", ";", "if", "(", "fun", "->", "machine", "->", "base_reg", ")", "emit_insn_at_entry", "(", "gen_main_pool", "(", "fun", "->", "machine", "->", "base_reg", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "annotate_constant_pool_refs", "(", "insn", ")", ";", "df_insn_rescan", "(", "insn", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_ld_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg0", ";", "machine_mode", "tmode", ",", "mode0", ";", "rtx", "pat", ",", "op0", ";", "enum", "insn_code", "icode", ";", "switch", "(", "fcode", ")", "{", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_16qi", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v16qi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_8hi", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v8hi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_4si", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v4si", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_4sf", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v4sf", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_2df", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v2df", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_2di", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v2di", ";", "break", ";", "case", "ALTIVEC_BUILTIN_LD_INTERNAL_1ti", ":", "icode", "=", "CODE_FOR_vector_altivec_load_v1ti", ";", "break", ";", "default", ":", "*", "expandedp", "=", "false", ";", "return", "NULL_RTX", ";", "}", "*", "expandedp", "=", "true", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "the", "lvx", "builtins", "." ]

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

[]

[ "<s>", "void", "push", "(", "unsigned", "Weight", ",", "const", "Candidate", "&&", "C", ")", "{", "operator", "[", "]", "(", "Weight", ")", ".", "push_front", "(", "C", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "else", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "SPIRVAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "ModuleSectionsEmitted", "==", "false", ")", "{", "outputModuleSections", "(", ")", ";", "ModuleSectionsEmitted", "=", "true", ";", "}", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "SPIRV", "SPIRV" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "LocInfo", "::", "AExt", ")", "{", "Size", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "ValVReg", "=", "MIRBuilder", ".", "buildAnyExt", "(", "LLT", "::", "scalar", "(", "Size", "*", "8", ")", ",", "ValVReg", ")", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "1", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AArch64", "8", "8", "0", "1" ]

[]

[ "<s>", "void", "ARMOperand", "::", "dump", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "CondCode", ":", "OS", "<<", "ARMCondCodeToString", "(", "getCondCode", "(", ")", ")", ";", "break", ";", "case", "CCOut", ":", "OS", "<<", "\"<ccout \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "Memory", ":", "OS", "<<", "\"<memory>\"", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "RegisterList", ":", "case", "DPRRegisterList", ":", "case", "SPRRegisterList", ":", "{", "OS", "<<", "\"<register_list \"", ";", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "RegList", "=", "getRegList", "(", ")", ";", "for", "(", "SmallVectorImpl", "<", "unsigned", ">", "::", "const_iterator", "I", "=", "RegList", ".", "begin", "(", ")", ",", "E", "=", "RegList", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "OS", "<<", "*", "I", ";", "if", "(", "++", "I", "<", "E", ")", "OS", "<<", "\", \"", ";", "}", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"<ccout \"", "\">\"", "\"<memory>\"", "\"<register \"", "\">\"", "\"<register_list \"", "\", \"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "unsigned", "mmix_dbx_register_number", "(", "unsigned", "regno", ")", "{", "regno", "=", "MMIX_OUTPUT_REGNO", "(", "regno", ")", ";", "return", "regno", ">=", "224", "?", "(", "regno", "-", "224", ")", ":", "(", "regno", "+", "48", ")", ";", "}", "</s>" ]

[ "DBX_REGISTER_NUMBER", "." ]

[ "mmix", "224", "224", "48" ]

[]

[ "<s>", "static", "int", "mips_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "if", "(", "mips_far_type_p", "(", "type1", ")", "&&", "mips_near_type_p", "(", "type2", ")", ")", "return", "0", ";", "if", "(", "mips_near_type_p", "(", "type1", ")", "&&", "mips_far_type_p", "(", "type2", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_COMP_TYPE_ATTRIBUTES", "." ]

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

[]

[ "<s>", "void", "AMDGPUTTI", "::", "getUnrollingPreferences", "(", "const", "Function", "*", ",", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "MaxCount", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "800", ";", "}", "}", "}", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "R600", "300", "AMDGPUAS::PRIVATE_ADDRESS", "800" ]

[]

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

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

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

[]

[ "<s>", "TargetLoweringBase", "::", "AtomicRMWExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "<=", "128", "?", "AtomicRMWExpansionKind", "::", "LLSC", ":", "AtomicRMWExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

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

[]

[ "<s>", "void", "d30v_expand_prologue", "(", ")", "{", "rtx", "sp", "=", "stack_pointer_rtx", ";", "d30v_stack_t", "*", "info", "=", "d30v_stack_info", "(", ")", ";", "int", "i", ";", "rtx", "mem_di", "=", "NULL_RTX", ";", "rtx", "mem_si", "=", "NULL_RTX", ";", "int", "num_memrefs", "=", "(", "info", "->", "memrefs_2words", "+", "info", "->", "memrefs_1word", "+", "info", "->", "memrefs_varargs", ")", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "debug_stack_info", "(", "info", ")", ";", "if", "(", "info", "->", "total_size", ")", "emit_insn", "(", "gen_addsi3", "(", "sp", ",", "sp", ",", "GEN_INT", "(", "-", "info", "->", "total_size", ")", ")", ")", ";", "if", "(", "num_memrefs", ">", "1", ")", "{", "rtx", "save_tmp", "=", "gen_rtx", "(", "REG", ",", "Pmode", ",", "GPR_STACK_TMP", ")", ";", "rtx", "post_inc", "=", "gen_rtx", "(", "POST_INC", ",", "Pmode", ",", "save_tmp", ")", ";", "mem_di", "=", "gen_rtx", "(", "MEM", ",", "DImode", ",", "post_inc", ")", ";", "mem_si", "=", "gen_rtx", "(", "MEM", ",", "SImode", ",", "post_inc", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "save_tmp", ",", "sp", ",", "GEN_INT", "(", "info", "->", "save_offset", ")", ")", ")", ";", "}", "else", "if", "(", "num_memrefs", "==", "1", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "sp", ",", "info", "->", "save_offset", ")", ";", "mem_di", "=", "gen_rtx", "(", "MEM", ",", "DImode", ",", "addr", ")", ";", "mem_si", "=", "gen_rtx", "(", "MEM", ",", "SImode", ",", "addr", ")", ";", "}", "for", "(", "i", "=", "ACCUM_FIRST", ";", "i", "<=", "ACCUM_LAST", ";", "i", "++", ")", "if", "(", "info", "->", "save_p", "[", "i", "]", ")", "{", "rtx", "acc_tmp", "=", "gen_rtx", "(", "REG", ",", "DImode", ",", "GPR_ATMP_FIRST", ")", ";", "emit_insn", "(", "gen_movdi", "(", "acc_tmp", ",", "gen_rtx", "(", "REG", ",", "DImode", ",", "i", ")", ")", ")", ";", "emit_insn", "(", "gen_movdi", "(", "mem_di", ",", "acc_tmp", ")", ")", ";", "}", "for", "(", "i", "=", "GPR_FIRST", ";", "i", "<=", "GPR_LAST", ";", "i", "+=", "2", ")", "if", "(", "info", "->", "save_p", "[", "i", "]", "==", "2", ")", "emit_insn", "(", "gen_movdi", "(", "mem_di", ",", "gen_rtx", "(", "REG", ",", "DImode", ",", "i", ")", ")", ")", ";", "for", "(", "i", "=", "GPR_FIRST", ";", "i", "<=", "GPR_LAST", ";", "i", "++", ")", "if", "(", "info", "->", "save_p", "[", "i", "]", "==", "1", ")", "emit_insn", "(", "gen_movsi", "(", "mem_si", ",", "gen_rtx", "(", "REG", ",", "SImode", ",", "i", ")", ")", ")", ";", "if", "(", "info", "->", "varargs_p", ")", "{", "if", "(", "(", "info", "->", "memrefs_1word", "&", "1", ")", "!=", "0", ")", "{", "rtx", "save_tmp", "=", "XEXP", "(", "XEXP", "(", "mem_si", ",", "0", ")", ",", "0", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "save_tmp", ",", "save_tmp", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ")", ";", "}", "for", "(", "i", "=", "GPR_ARG_FIRST", ";", "i", "<=", "GPR_ARG_LAST", ";", "i", "+=", "2", ")", "emit_insn", "(", "gen_movdi", "(", "mem_di", ",", "gen_rtx", "(", "REG", ",", "DImode", ",", "i", ")", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_move_insn", "(", "frame_pointer_rtx", ",", "sp", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "prologue", ".", "Using", "a", "prologue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "output_function_prologue", "(", ")", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "d30v", "1", "1", "2", "2", "1", "1", "0", "0", "0", "2" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "Mips", "MVT::i32" ]

[]

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

[ "Tests", "whether", "the", "target", "triple", "is", "little", "endian", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "SNESDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "isSigned", "(", "const", "SelectInst", "&", "I", ")", "const", "{", "return", "isa", "<", "ICmpInst", ">", "(", "I", ".", "getOperand", "(", "0", ")", ")", "?", "cast", "<", "ICmpInst", ">", "(", "I", ".", "getOperand", "(", "0", ")", ")", "->", "isSigned", "(", ")", ":", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "all", "source", "operands", "of", "the", "recurrence", "are", "SExtInsts", "." ]

[ "AMDGPU", "AMDGPU", "0", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isPredicable", "(", ")", ")", "return", "false", ";", "ARMFunctionInfo", "*", "AFI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "getSubtarget", "(", ")", ".", "restrictIT", "(", ")", ")", "return", "isV8EligibleForIT", "(", "MI", ")", ";", "}", "else", "{", "if", "(", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "Stack", ".", "empty", "(", ")", "||", "top", "(", ")", "==", "bottom", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "int", "uses_TOC", "(", "void", ")", "{", "rtx", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "sub", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "USE", ")", "{", "sub", "=", "XEXP", "(", "sub", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "UNSPEC", "&&", "XINT", "(", "sub", ",", "1", ")", "==", "UNSPEC_TOC", ")", "return", "1", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "retuns", "nonzero", "if", "the", "current", "function", "uses", "the", "TOC", ".", "This", "is", "determined", "by", "the", "presence", "of", "(", "unspec", "...", "7", ")", ",", "which", "is", "generated", "by", "the", "various", "load_toc_", "*", "patterns", "." ]

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

[]

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

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

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

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "WRYrr", ",", "dl", ",", "MVT", "::", "Glue", ",", "TopPart", ",", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "}", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "{", "SDValue", "MulLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "MulRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "MULHU", "?", "SP", "::", "UMULrr", ":", "SP", "::", "SMULrr", ";", "SDNode", "*", "Mul", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Glue", ",", "MulLHS", ",", "MulRHS", ")", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "SP", "::", "RDY", ",", "MVT", "::", "i32", ",", "SDValue", "(", "Mul", ",", "1", ")", ")", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::WRYrr", "MVT::Glue", "SP::G0", "MVT::i32", "0", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32", "ISD::MULHU", "ISD::MULHS", "0", "1", "ISD::MULHU", "SP::UMULrr", "SP::SMULrr", "MVT::i32", "MVT::Glue", "SP::RDY", "MVT::i32", "1" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_find_pool", "(", "struct", "constant_pool", "*", "pool_list", ",", "rtx", "insn", ")", "{", "struct", "constant_pool", "*", "pool", ";", "for", "(", "pool", "=", "pool_list", ";", "pool", ";", "pool", "=", "pool", "->", "next", ")", "if", "(", "bitmap_bit_p", "(", "pool", "->", "insns", ",", "INSN_UID", "(", "insn", ")", ")", ")", "break", ";", "return", "pool", ";", "}", "</s>" ]

[ "Return", "pool", "out", "of", "POOL_LIST", "that", "covers", "INSN", "." ]

[ "s390" ]

[]

[ "<s>", "void", "AVRDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "const", "LegalizerInfo", "*", "getLegalizerInfo", "(", ")", "const", "override", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "M88k" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "selectBinaryOp", "(", "MachineInstr", "&", "I", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "unsigned", "DefReg", "=", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "DefReg", ")", ";", "const", "RegisterBank", "&", "RB", "=", "*", "RBI", ".", "getRegBank", "(", "DefReg", ",", "MRI", ",", "TRI", ")", ";", "unsigned", "NewOpc", "=", "I", ".", "getOpcode", "(", ")", ";", "switch", "(", "NewOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "NewOpc", "=", "getFAddOp", "(", "Ty", ",", "RB", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "NewOpc", "=", "getFSubOp", "(", "Ty", ",", "RB", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "NewOpc", "=", "getAddOp", "(", "Ty", ",", "RB", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_SUB", ":", "NewOpc", "=", "getSubOp", "(", "Ty", ",", "RB", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "NewOpc", "==", "I", ".", "getOpcode", "(", ")", ")", "return", "false", ";", "I", ".", "setDesc", "(", "TII", ".", "get", "(", "NewOpc", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "I", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "</s>" ]

[ "Select", "and", "emit", "code", "for", "a", "binary", "operator", "instruction", ",", "which", "has", "an", "opcode", "which", "directly", "corresponds", "to", "the", "given", "ISD", "opcode", "." ]

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

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "BitVector", "M680x0RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "M680x0FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "auto", "setBitVector", "=", "[", "&", "Reserved", ",", "this", "]", "(", "unsigned", "Reg", ")", "{", "for", "(", "MCRegAliasIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "for", "(", "MCSubRegIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "}", ";", "setBitVector", "(", "M680x0", "::", "PC", ")", ";", "setBitVector", "(", "M680x0", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "setBitVector", "(", "FramePtr", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"", ")", ";", "setBitVector", "(", "getBaseRegister", "(", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "M680x0::PC", "M680x0::SP", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "int", "Cost", "=", "0", ";", "if", "(", "isWideningInstruction", "(", "Ty", ",", "Opcode", ",", "Args", ")", ")", "Cost", "+=", "ST", "->", "getWideningBaseCost", "(", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "if", "(", "ISD", "==", "ISD", "::", "SDIV", "&&", "Opd2Info", "==", "TargetTransformInfo", "::", "OK_UniformConstantValue", "&&", "Opd2PropInfo", "==", "TargetTransformInfo", "::", "OP_PowerOf2", ")", "{", "Cost", "+=", "getArithmeticInstrCost", "(", "Instruction", "::", "Add", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "TargetTransformInfo", "::", "OP_None", ",", "TargetTransformInfo", "::", "OP_None", ")", ";", "Cost", "+=", "getArithmeticInstrCost", "(", "Instruction", "::", "Sub", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "TargetTransformInfo", "::", "OP_None", ",", "TargetTransformInfo", "::", "OP_None", ")", ";", "Cost", "+=", "getArithmeticInstrCost", "(", "Instruction", "::", "Select", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "TargetTransformInfo", "::", "OP_None", ",", "TargetTransformInfo", "::", "OP_None", ")", ";", "Cost", "+=", "getArithmeticInstrCost", "(", "Instruction", "::", "AShr", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "TargetTransformInfo", "::", "OP_None", ",", "TargetTransformInfo", "::", "OP_None", ")", ";", "return", "Cost", ";", "}", "switch", "(", "ISD", ")", "{", "default", ":", "return", "Cost", "+", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "return", "(", "Cost", "+", "1", ")", "*", "LT", ".", "first", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "ISD::SDIV", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "1" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_XCore", ")", ";", "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", "." ]

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

[]

[ "<s>", "bool", "ARMFastISel", "::", "fastLowerArguments", "(", ")", "{", "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "const", "Function", "*", "F", "=", "FuncInfo", ".", "Fn", ";", "if", "(", "F", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "CallingConv", "::", "ID", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "return", "false", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "ARM_AAPCS", ":", "case", "CallingConv", "::", "ARM_APCS", ":", "case", "CallingConv", "::", "Swift", ":", "break", ";", "}", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->", "arg_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "Idx", ")", "{", "if", "(", "Idx", ">", "4", ")", "return", "false", ";", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "InReg", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "StructRet", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SwiftSelf", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SwiftError", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ByVal", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "I", "->", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "break", ";", "default", ":", "return", "false", ";", "}", "}", "static", "const", "MCPhysReg", "GPRArgRegs", "[", "]", "=", "{", "ARM", "::", "R0", ",", "ARM", "::", "R1", ",", "ARM", "::", "R2", ",", "ARM", "::", "R3", "}", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "rGPRRegClass", ";", "Idx", "=", "0", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->", "arg_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "Idx", ")", "{", "unsigned", "SrcReg", "=", "GPRArgRegs", "[", "Idx", "]", ";", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "updateValueMap", "(", "&", "*", "I", ",", "ResultReg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "argument", "lowering", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "1", "4", "MVT::i8", "MVT::i16", "MVT::i32", "ARM::R0", "ARM::R1", "ARM::R2", "ARM::R3", "ARM::rGPRRegClass", "0" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateMem", "(", "unsigned", "ModeSize", ",", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "unsigned", "DefaultBaseReg", "=", "X86", "::", "NoRegister", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ",", "unsigned", "FrontendSize", "=", "0", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", "||", "DefaultBaseReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "auto", "Res", "=", "std", "::", "make_unique", "<", "X86Operand", ">", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "DefaultBaseReg", "=", "DefaultBaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "ModeSize", "=", "ModeSize", ";", "Res", "->", "Mem", ".", "FrontendSize", "=", "FrontendSize", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "X86::NoRegister", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "int", "nds32_target_alignment", "(", "rtx_insn", "*", "label", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "NDS32_ALIGN_P", "(", ")", ")", "return", "0", ";", "insn", "=", "next_active_insn", "(", "label", ")", ";", "if", "(", "insn", "==", "0", "||", "(", "get_attr_length", "(", "insn", ")", "==", "2", "&&", "!", "JUMP_P", "(", "insn", ")", "&&", "!", "CALL_P", "(", "insn", ")", ")", ")", "return", "0", ";", "else", "return", "2", ";", "}", "</s>" ]

[ "Return", "align", "2", "(", "log", "base", "2", ")", "if", "the", "next", "instruction", "of", "LABEL", "is", "4", "byte", "." ]

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

[]

[ "<s>", "static", "bool", "adjacent_mem_locations", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "reg1", ",", "reg2", ";", "HOST_WIDE_INT", "off1", ",", "size1", ",", "off2", ",", "size2", ";", "if", "(", "get_memref_parts", "(", "mem1", ",", "&", "reg1", ",", "&", "off1", ",", "&", "size1", ")", "&&", "get_memref_parts", "(", "mem2", ",", "&", "reg2", ",", "&", "off2", ",", "&", "size2", ")", ")", "return", "(", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", ")", "&&", "(", "(", "off1", "+", "size1", "==", "off2", ")", "||", "(", "off2", "+", "size2", "==", "off1", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "target", "storage", "locations", "of", "arguments", "MEM1", "and", "MEM2", "are", "adjacent", ",", "then", "return", "the", "argument", "that", "has", "the", "lower", "address", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "s390_split_ok_p", "(", "rtx", "dst", ",", "rtx", "src", ",", "machine_mode", "mode", ",", "int", "first_subword", ")", "{", "if", "(", "FP_REG_P", "(", "src", ")", "||", "FP_REG_P", "(", "dst", ")", "||", "VECTOR_REG_P", "(", "src", ")", "||", "VECTOR_REG_P", "(", "dst", ")", ")", "return", "false", ";", "if", "(", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "!", "offsettable_memref_p", "(", "src", ")", ")", "||", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "!", "offsettable_memref_p", "(", "dst", ")", ")", ")", "return", "false", ";", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", ")", "{", "rtx", "subreg", "=", "operand_subword", "(", "dst", ",", "first_subword", ",", "0", ",", "mode", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "subreg", ",", "src", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "we", "can", "(", "and", "want", "to", ")", "split", "a", "double-word", "move", "in", "mode", "MODE", "from", "SRC", "to", "DST", "into", "two", "single-word", "moves", ",", "moving", "the", "subword", "FIRST_SUBWORD", "first", "." ]

[ "s390", "0" ]

[]

[ "<s>", "int", "s390_agen_dep_p", "(", "rtx", "dep_insn", ",", "rtx", "insn", ")", "{", "rtx", "dep_rtx", "=", "PATTERN", "(", "dep_insn", ")", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "dep_rtx", ")", "==", "SET", "&&", "addr_generation_dependency_p", "(", "dep_rtx", ",", "insn", ")", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "dep_rtx", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "dep_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "if", "(", "addr_generation_dependency_p", "(", "XVECEXP", "(", "dep_rtx", ",", "0", ",", "i", ")", ",", "insn", ")", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", ",", "if", "dep_insn", "sets", "register", "used", "in", "insn", "in", "the", "agen", "unit", "." ]

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

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "isGPRMem", "(", ")", "||", "isMVEMem", "(", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "struct", "xstormy16_stack_layout", "xstormy16_compute_stack_layout", "(", "void", ")", "{", "struct", "xstormy16_stack_layout", "layout", ";", "int", "regno", ";", "const", "int", "ifun", "=", "xstormy16_interrupt_function_p", "(", ")", ";", "layout", ".", "locals_size", "=", "get_frame_size", "(", ")", ";", "layout", ".", "register_save_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "REG_NEEDS_SAVE", "(", "regno", ",", "ifun", ")", ")", "layout", ".", "register_save_size", "+=", "UNITS_PER_WORD", ";", "if", "(", "cfun", "->", "stdarg", ")", "layout", ".", "stdarg_save_size", "=", "NUM_ARGUMENT_REGISTERS", "*", "UNITS_PER_WORD", ";", "else", "layout", ".", "stdarg_save_size", "=", "0", ";", "layout", ".", "frame_size", "=", "(", "layout", ".", "locals_size", "+", "layout", ".", "register_save_size", "+", "layout", ".", "stdarg_save_size", ")", ";", "if", "(", "crtl", "->", "args", ".", "size", "<=", "2048", "&&", "crtl", "->", "args", ".", "size", "!=", "-", "1", ")", "{", "if", "(", "layout", ".", "frame_size", "-", "INCOMING_FRAME_SP_OFFSET", "+", "crtl", "->", "args", ".", "size", "<=", "2048", ")", "layout", ".", "fp_minus_ap", "=", "layout", ".", "frame_size", "-", "INCOMING_FRAME_SP_OFFSET", ";", "else", "layout", ".", "fp_minus_ap", "=", "2048", "-", "crtl", "->", "args", ".", "size", ";", "}", "else", "layout", ".", "fp_minus_ap", "=", "(", "layout", ".", "stdarg_save_size", "+", "layout", ".", "register_save_size", "-", "INCOMING_FRAME_SP_OFFSET", ")", ";", "layout", ".", "sp_minus_fp", "=", "(", "layout", ".", "frame_size", "-", "INCOMING_FRAME_SP_OFFSET", "-", "layout", ".", "fp_minus_ap", ")", ";", "layout", ".", "first_local_minus_ap", "=", "layout", ".", "sp_minus_fp", "-", "layout", ".", "locals_size", ";", "return", "layout", ";", "}", "</s>" ]

[ "Compute", "the", "stack", "layout", "." ]

[ "stormy16", "0", "0", "0", "2048", "1", "2048", "2048" ]

[]

[ "<s>", "const", "Thumb1RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "quad_load_store_p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "bool", "ret", ";", "if", "(", "!", "TARGET_QUAD_MEMORY", ")", "ret", "=", "false", ";", "else", "if", "(", "REG_P", "(", "op0", ")", "&&", "MEM_P", "(", "op1", ")", ")", "ret", "=", "(", "quad_int_reg_operand", "(", "op0", ",", "GET_MODE", "(", "op0", ")", ")", "&&", "quad_memory_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "op0", ",", "op1", ")", ")", ";", "else", "if", "(", "MEM_P", "(", "op0", ")", "&&", "REG_P", "(", "op1", ")", ")", "ret", "=", "(", "quad_memory_operand", "(", "op0", ",", "GET_MODE", "(", "op0", ")", ")", "&&", "quad_int_reg_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", ")", ";", "else", "ret", "=", "false", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n========== quad_load_store, return %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load", "or", "store", "quad", "operation", ".", "This", "function", "does", "not", "handle", "the", "atomic", "quad", "memory", "instructions", "." ]

[ "rs6000", "\"\\n========== quad_load_store, return %s\\n\"", "\"true\"", "\"false\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "KudeyarTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "Opc", "==", "Kudeyar", "::", "Select32T", "||", "Opc", "==", "Kudeyar", "::", "Select32F", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "splice", "(", "copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "int", "br_code", ";", "switch", "(", "Opc", ")", "{", "case", "Kudeyar", "::", "Select32T", ":", "br_code", "=", "Kudeyar", "::", "BTs", ";", "break", ";", "case", "Kudeyar", "::", "Select32F", ":", "br_code", "=", "Kudeyar", "::", "BFs", ";", "break", ";", "default", ":", "br_code", "=", "0", ";", "}", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "br_code", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "Kudeyar", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar::Select32T", "Kudeyar::Select32F", "\"Unexpected instr type to insert\"", "Kudeyar::Select32T", "Kudeyar::BTs", "Kudeyar::Select32F", "Kudeyar::BFs", "0", "Kudeyar::PHI", "0", "2", "1" ]

[]

[ "<s>", "int", "m32c_eh_return_data_regno", "(", "int", "n", ")", "{", "switch", "(", "n", ")", "{", "case", "0", ":", "return", "A0_REGNO", ";", "case", "1", ":", "return", "A1_REGNO", ";", "default", ":", "return", "INVALID_REGNUM", ";", "}", "}", "</s>" ]

[ "Implements", "EH_RETURN_DATA_REGNO", ".", "Choose", "registers", "able", "to", "hold", "pointers", "." ]

[ "m32c", "0", "1" ]

[]

[ "<s>", "void", "build_mask64_2_operands", "(", "rtx", "in", ",", "rtx", "*", "out", ")", "{", "unsigned", "HOST_WIDE_INT", "c", ",", "lsb", ",", "m1", ",", "m2", ";", "int", "shift", ";", "gcc_assert", "(", "GET_CODE", "(", "in", ")", "==", "CONST_INT", ")", ";", "c", "=", "INTVAL", "(", "in", ")", ";", "if", "(", "c", "&", "1", ")", "{", "c", "=", "~", "c", ";", "lsb", "=", "c", "&", "-", "c", ";", "m1", "=", "-", "lsb", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "shift", "=", "0", ";", "while", "(", "(", "lsb", ">>=", "1", ")", "!=", "0", ")", "shift", "++", ";", "m1", "<<=", "64", "-", "shift", ";", "m1", "=", "~", "m1", ";", "m2", "=", "~", "c", ";", "}", "else", "{", "lsb", "=", "c", "&", "-", "c", ";", "m2", "=", "-", "lsb", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "shift", "=", "0", ";", "while", "(", "(", "lsb", ">>=", "1", ")", "!=", "0", ")", "shift", "++", ";", "m1", "=", "~", "c", ";", "m1", ">>=", "shift", ";", "m1", "=", "~", "m1", ";", "}", "out", "[", "0", "]", "=", "GEN_INT", "(", "64", "-", "shift", ")", ";", "out", "[", "1", "]", "=", "GEN_INT", "(", "m1", ")", ";", "out", "[", "2", "]", "=", "GEN_INT", "(", "shift", ")", ";", "out", "[", "3", "]", "=", "GEN_INT", "(", "m2", ")", ";", "(", "void", ")", "in", ";", "(", "void", ")", "out", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Generates", "shifts", "and", "masks", "for", "a", "pair", "of", "rldicl", "or", "rldicr", "insns", "to", "implement", "ANDing", "by", "the", "mask", "IN", "." ]

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

[]

[ "<s>", "bool", "arm_simd_check_vect_par_cnst_half_p", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "high", ")", "{", "rtx", "ideal", "=", "arm_simd_vect_par_cnst_half", "(", "mode", ",", "high", ")", ";", "HOST_WIDE_INT", "count_op", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "count_ideal", "=", "XVECLEN", "(", "ideal", ",", "0", ")", ";", "int", "i", "=", "0", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "count_op", "!=", "count_ideal", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count_ideal", ";", "i", "++", ")", "{", "rtx", "elt_op", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "rtx", "elt_ideal", "=", "XVECEXP", "(", "ideal", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt_op", ")", "||", "INTVAL", "(", "elt_ideal", ")", "!=", "INTVAL", "(", "elt_op", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "OP", "for", "validity", "as", "a", "PARALLEL", "RTX", "vector", "with", "elements", "numbering", "the", "lanes", "of", "either", "the", "high", "(", "HIGH", "==", "TRUE", ")", "or", "low", "lanes", ",", "from", "the", "perspective", "of", "the", "architecture", ".", "See", "the", "diagram", "above", "arm_simd_vect_par_cnst_half_p", "for", "more", "details", "." ]

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

[]

[ "<s>", "void", "PTXMCAsmStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ")", "{", "assert", "(", "getCurrentSection", "(", ")", "&&", "\"Cannot emit contents before setting section!\"", ")", ";", "if", "(", "Emitter", ")", "AddEncodingComment", "(", "Inst", ")", ";", "if", "(", "ShowInst", ")", "{", "Inst", ".", "dump_pretty", "(", "GetCommentOS", "(", ")", ",", "&", "MAI", ",", "InstPrinter", ".", "get", "(", ")", ",", "\"\\n \"", ")", ";", "GetCommentOS", "(", ")", "<<", "\"\\n\"", ";", "}", "if", "(", "InstPrinter", ")", "InstPrinter", "->", "printInst", "(", "&", "Inst", ",", "OS", ")", ";", "else", "Inst", ".", "print", "(", "OS", ",", "&", "MAI", ")", ";", "EmitEOL", "(", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "PTX", "PTX", "\"Cannot emit contents before setting section!\"", "\"\\n \"", "\"\\n\"" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "ADJCALLSTACKDOWN", ")", "Size", "=", "-", "Size", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "Size", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "Size", ")", ";", "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", ")", "." ]

[ "Sparc", "Sparc", "0", "SP::ADJCALLSTACKDOWN", "Sparc", "Sparc", "SP::ADDri", "SP::O6", "SP::O6" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "void", "xtensa_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this_rtx", ";", "rtx", "funexp", ";", "rtx_insn", "*", "insn", ";", "int", "this_reg_no", ";", "rtx", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "A9_REG", ")", ";", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk", ")", ")", ";", "reload_completed", "=", "1", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_reg_no", "=", "3", ";", "else", "this_reg_no", "=", "2", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "A0_REG", "+", "this_reg_no", ")", ";", "if", "(", "delta", ")", "xtensa_emit_add_imm", "(", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp0", ",", "false", ")", ";", "if", "(", "vcall_offset", ")", "{", "rtx", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "A0_REG", "+", "10", ")", ";", "rtx", "addr", "=", "temp1", ";", "emit_move_insn", "(", "temp0", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "if", "(", "xtensa_uimm8x4", "(", "vcall_offset", ")", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "xtensa_emit_add_imm", "(", "temp1", ",", "temp0", ",", "vcall_offset", ",", "temp1", ",", "false", ")", ";", "emit_move_insn", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "xtensa", "1", "3", "2", "10", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "build_sv_index", "(", "function_builder", "&", "b", ",", "const", "char", "*", "signature", ",", "const", "function_group_info", "&", "group", ")", "{", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_s32index", ",", "MODE_s64index", ")", ";", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_u32index", ",", "MODE_u64index", ")", ";", "}", "</s>" ]

[ "For", "every", "type", "and", "predicate", "combination", "in", "GROUP", ",", "add", "one", "function", "that", "takes", "a", "scalar", "(", "pointer", ")", "base", "and", "a", "signed", "vector", "array", "index", ",", "and", "another", "that", "instead", "takes", "an", "unsigned", "vector", "array", "index", ".", "The", "vector", "array", "index", "has", "the", "same", "element", "size", "as", "the", "first", "function", "type", "suffix", ".", "SIGNATURE", "is", "as", "for", "build_all", "." ]

[ "aarch64" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "output_mov_double_arm_from_fpa", "(", "rtx", "*", "operands", ")", "{", "int", "arm_reg0", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "rtx", "ops", "[", "2", "]", ";", "gcc_assert", "(", "arm_reg0", "!=", "IP_REGNUM", ")", ";", "ops", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "arm_reg0", ")", ";", "ops", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "1", "+", "arm_reg0", ")", ";", "output_asm_insn", "(", "\"stf%?d\\t%1, [%|sp, #-8]!\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldm%?fd\\t%|sp!, {%0, %1}\"", ",", "ops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "move", "from", "an", "fpa", "register", "to", "arm", "registers", ".", "OPERANDS", "[", "0", "]", "is", "the", "first", "registers", "of", "an", "arm", "register", "pair", ".", "OPERANDS", "[", "1", "]", "is", "an", "fpa", "register", "." ]

[ "arm", "0", "2", "0", "1", "1", "\"stf%?d\\t%1, [%|sp, #-8]!\"", "\"ldm%?fd\\t%|sp!, {%0, %1}\"", "\"\"" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "const", "MCInstrInfo", "*", "MCII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "MCII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "auto", "&", "OI", ":", "enumerate", "(", "Desc", ".", "operands", "(", ")", ")", ")", "{", "unsigned", "OpType", "=", "OI", ".", "value", "(", ")", ".", "OperandType", ";", "if", "(", "OpType", ">=", "RISCVOp", "::", "OPERAND_FIRST_RISCV_IMM", "&&", "OpType", "<=", "RISCVOp", "::", "OPERAND_LAST_RISCV_IMM", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OI", ".", "index", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "bool", "Ok", ";", "switch", "(", "OpType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand type\"", ")", ";", "case", "RISCVOp", "::", "OPERAND_UIMM2", ":", "Ok", "=", "isUInt", "<", "2", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM3", ":", "Ok", "=", "isUInt", "<", "3", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM4", ":", "Ok", "=", "isUInt", "<", "4", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM5", ":", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM7", ":", "Ok", "=", "isUInt", "<", "7", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM12", ":", "Ok", "=", "isUInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM12", ":", "Ok", "=", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM20", ":", "Ok", "=", "isUInt", "<", "20", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMMLOG2XLEN", ":", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "Ok", "=", "isUInt", "<", "6", ">", "(", "Imm", ")", ";", "else", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "}", "if", "(", "!", "Ok", ")", "{", "ErrInfo", "=", "\"Invalid immediate\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "RISCV", "RISCV", "RISCVOp::OPERAND_FIRST_RISCV_IMM", "RISCVOp::OPERAND_LAST_RISCV_IMM", "\"Unexpected operand type\"", "RISCVOp::OPERAND_UIMM2", "2", "RISCVOp::OPERAND_UIMM3", "3", "RISCVOp::OPERAND_UIMM4", "4", "RISCVOp::OPERAND_UIMM5", "5", "RISCVOp::OPERAND_UIMM7", "7", "RISCVOp::OPERAND_UIMM12", "12", "RISCVOp::OPERAND_SIMM12", "12", "RISCVOp::OPERAND_UIMM20", "20", "RISCVOp::OPERAND_UIMMLOG2XLEN", "6", "5", "\"Invalid immediate\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "if", "(", "getMipsSubtarget", "(", ")", ".", "allowMixed16_32", "(", ")", ")", "{", "addPass", "(", "createMipsModuleISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMips16ISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMipsSEISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "else", "{", "addPass", "(", "createMipsISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "SUnit", "*", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Patmos", "0" ]

[]

[ "<s>", "int", "h8300_eightbit_constant_address_p", "(", "rtx", "x", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "n1", "=", "trunc_int_for_mode", "(", "0xff00", ",", "HImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "n2", "=", "trunc_int_for_mode", "(", "0xffff", ",", "HImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "h1", "=", "trunc_int_for_mode", "(", "0x00ffff00", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "h2", "=", "trunc_int_for_mode", "(", "0x00ffffff", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s1", "=", "trunc_int_for_mode", "(", "0xffffff00", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s2", "=", "trunc_int_for_mode", "(", "0xffffffff", ",", "SImode", ")", ";", "unsigned", "HOST_WIDE_INT", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_EIGHTBIT_DATA", ")", "!=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "return", "0", ";", "addr", "=", "INTVAL", "(", "x", ")", ";", "return", "(", "0", "||", "(", "(", "TARGET_H8300", "||", "TARGET_NORMAL_MODE", ")", "&&", "IN_RANGE", "(", "addr", ",", "n1", ",", "n2", ")", ")", "||", "(", "TARGET_H8300H", "&&", "IN_RANGE", "(", "addr", ",", "h1", ",", "h2", ")", ")", "||", "(", "TARGET_H8300S", "&&", "IN_RANGE", "(", "addr", ",", "s1", ",", "s2", ")", ")", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "X", "is", "a", "constant", "address", "suitable", "as", "an", "8-bit", "absolute", ",", "which", "is", "a", "special", "case", "of", "the", "'", "R", "'", "operand", "." ]

[ "h8300", "0xff00", "0xffff", "0x00ffff00", "0x00ffffff", "0xffffff00", "0xffffffff", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "mn10300_builtin_saveregs", "(", "void", ")", "{", "rtx", "offset", ",", "mem", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "int", "argadj", "=", "(", "(", "!", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ")", "?", "UNITS_PER_WORD", ":", "0", ")", ";", "int", "set", "=", "get_varargs_alias_set", "(", ")", ";", "if", "(", "argadj", ")", "offset", "=", "plus_constant", "(", "current_function_arg_offset_rtx", ",", "argadj", ")", ";", "else", "offset", "=", "current_function_arg_offset_rtx", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "current_function_internal_arg_pointer", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "current_function_internal_arg_pointer", ",", "4", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ")", ";", "return", "copy_to_reg", "(", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "current_function_internal_arg_pointer", ",", "offset", ",", "0", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ")", ";", "}", "</s>" ]

[ "Flush", "the", "argument", "registers", "to", "the", "stack", "for", "a", "stdarg", "function", ";", "return", "the", "new", "argument", "pointer", "." ]

[ "mn10300", "0", "0", "0", "4", "1", "0", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "(", "RC", "->", "getSize", "(", ")", "/", "8", ")", "==", "32", "?", "32", ":", "16", ";", "bool", "isAligned", "=", "(", "TM", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "32", "32", "16" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "{", "PM", ".", "add", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "PM", ".", "add", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128RegClass", "X86" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_func_type", "(", ")", "{", "unsigned", "long", "type", "=", "ARM_FT_UNKNOWN", ";", "tree", "a", ";", "tree", "attr", ";", "if", "(", "TREE_CODE", "(", "current_function_decl", ")", "!=", "FUNCTION_DECL", ")", "abort", "(", ")", ";", "if", "(", "optimize", ">", "0", "&&", "current_function_nothrow", "&&", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "type", "|=", "ARM_FT_VOLATILE", ";", "if", "(", "current_function_needs_context", ")", "type", "|=", "ARM_FT_NESTED", ";", "attr", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "attr", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "type", "|=", "ARM_FT_NAKED", ";", "if", "(", "cfun", "->", "machine", "->", "eh_epilogue_sp_ofs", "!=", "NULL_RTX", ")", "type", "|=", "ARM_FT_EXCEPTION_HANDLER", ";", "else", "{", "a", "=", "lookup_attribute", "(", "\"isr\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "type", "|=", "TARGET_INTERWORK", "?", "ARM_FT_INTERWORKED", ":", "ARM_FT_NORMAL", ";", "else", "type", "|=", "arm_isr_value", "(", "TREE_VALUE", "(", "a", ")", ")", ";", "}", "return", "type", ";", "}", "</s>" ]

[ "Computes", "the", "type", "of", "the", "current", "function", "." ]

[ "arm", "0", "\"naked\"", "\"isr\"", "\"interrupt\"" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

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

[ "CSKY" ]

[]

[ "<s>", "static", "int", "sh_symbian_get_strip_length", "(", "int", "c", ")", "{", "return", "(", "c", "==", "SH_SYMBIAN_FLAG_CHAR", "[", "0", "]", ")", "?", "strlen", "(", "DLL_EXPORT_PREFIX", ")", ":", "0", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "a", "function", "name", "prefix", "that", "starts", "with", "the", "character", "'", "c", "'", "." ]

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

[]

[ "<s>", "static", "rtx", "function_value_32", "(", "machine_mode", "orig_mode", ",", "machine_mode", "mode", ",", "const_tree", "fntype", ",", "const_tree", "fn", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "regno", "=", "FIRST_MMX_REG", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_FLOAT_RETURNS_IN_80387", ")", "regno", "=", "FIRST_FLOAT_REG", ";", "else", "regno", "=", "AX_REG", ";", "if", "(", "(", "fn", "||", "fntype", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "{", "int", "sse_level", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fn", ",", "false", ")", ";", "if", "(", "sse_level", "==", "-", "1", ")", "{", "error", "(", "\"calling %qD with SSE caling convention without \"", "\"SSE/SSE2 enabled\"", ",", "fn", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "else", "if", "(", "(", "sse_level", ">=", "1", "&&", "mode", "==", "SFmode", ")", "||", "(", "sse_level", "==", "2", "&&", "mode", "==", "DFmode", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "}", "gcc_assert", "(", "mode", "!=", "OImode", ")", ";", "return", "gen_rtx_REG", "(", "orig_mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", "." ]

[ "i386", "8", "16", "32", "64", "1", "\"calling %qD with SSE caling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", "1", "2" ]

[]

[ "<s>", "bool", "isReg", "(", "RegisterKind", "RegKind", ")", "const", "{", "return", "Kind", "==", "KindReg", "&&", "Reg", ".", "Kind", "==", "RegKind", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "static", "bool", "lm32_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "strict", "&&", "REG_P", "(", "x", ")", "&&", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "!", "strict", "&&", "REG_P", "(", "x", ")", "&&", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "(", "(", "strict", "&&", "STRICT_REG_OK_FOR_BASE_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "||", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "satisfies_constraint_K", "(", "XEXP", "(", "(", "x", ")", ",", "1", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

[ "lm32", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "Node", "*", "update", "(", "Node", "*", "N", ")", "{", "assert", "(", "N", "!=", "nullptr", ")", ";", "N", "->", "Height", "=", "1", "+", "std", "::", "max", "(", "height", "(", "N", "->", "Left", ")", ",", "height", "(", "N", "->", "Right", ")", ")", ";", "if", "(", "N", "->", "Left", ")", "N", "->", "MaxEnd", "=", "std", "::", "max", "(", "N", "->", "MaxEnd", ",", "N", "->", "Left", "->", "MaxEnd", ")", ";", "if", "(", "N", "->", "Right", ")", "N", "->", "MaxEnd", "=", "std", "::", "max", "(", "N", "->", "MaxEnd", ",", "N", "->", "Right", "->", "MaxEnd", ")", ";", "return", "N", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "Hexagon", "1" ]

[]

[ "<s>", "static", "void", "fusion_split_address", "(", "rtx", "addr", ",", "rtx", "*", "p_hi", ",", "rtx", "*", "p_lo", ")", "{", "rtx", "hi", ",", "lo", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "hi", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "lo", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "*", "p_hi", "=", "hi", ";", "*", "p_lo", "=", "lo", ";", "}", "</s>" ]

[ "Given", "an", "address", ",", "convert", "it", "into", "the", "addis", "and", "load", "offset", "parts", ".", "Addresses", "created", "during", "the", "peephole2", "process", "look", "like", ":", "(", "lo_sum", "(", "high", "(", "unspec", "[", "(", "sym", ")", "]", "UNSPEC_TOCREL", ")", ")", "(", "unspec", "[", "(", "...", ")", "]", "UNSPEC_TOCREL", ")", ")" ]

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

[]

[ "<s>", "void", "m32c_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "0", "<=", "target_memregs", "&&", "target_memregs", "<=", "16", ")", "{", "for", "(", "i", "=", "(", "target_memregs", "+", "1", ")", "/", "2", ";", "i", "<", "8", ";", "i", "++", ")", "{", "fixed_regs", "[", "MEM0_REGNO", "+", "i", "]", "=", "1", ";", "CLEAR_HARD_REG_BIT", "(", "reg_class_contents", "[", "MEM_REGS", "]", ",", "MEM0_REGNO", "+", "i", ")", ";", "}", "}", "if", "(", "TARGET_A24", ")", "{", "call_used_regs", "[", "R1_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "R2_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "R3_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "A0_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "A1_REGNO", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "Implements", "CONDITIONAL_REGISTER_USAGE", ".", "We", "adjust", "the", "number", "of", "available", "memregs", ",", "and", "select", "which", "registers", "need", "to", "be", "preserved", "across", "calls", "based", "on", "the", "chip", "family", "." ]

[ "m32c", "0", "16", "1", "2", "8", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "NVPTXRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "(", "InstrInfo", ".", "getRegisterInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "divmod_p", "(", "rtx_insn", "*", "insn", ")", "{", "gcc_assert", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_DIV", ")", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_divmodsi4", "||", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_udivmodsi4", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "the", "DIV", "insn", "needs", "two", "write", "ports", "." ]

[ "nds32" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MIPS Os16 Optimization\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS Os16 Optimization\"" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "LLVMContext", "&", "Context", "=", "M", ".", "getContext", "(", ")", ";", "Void", "=", "Type", "::", "getVoidTy", "(", "Context", ")", ";", "Boolean", "=", "Type", "::", "getInt1Ty", "(", "Context", ")", ";", "Int64", "=", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "ReturnStruct", "=", "StructType", "::", "get", "(", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "BoolTrue", "=", "ConstantInt", "::", "getTrue", "(", "Context", ")", ";", "BoolFalse", "=", "ConstantInt", "::", "getFalse", "(", "Context", ")", ";", "BoolUndef", "=", "UndefValue", "::", "get", "(", "Boolean", ")", ";", "Int64Zero", "=", "ConstantInt", "::", "get", "(", "Int64", ",", "0", ")", ";", "If", "=", "M", ".", "getOrInsertFunction", "(", "IfIntrinsic", ",", "ReturnStruct", ",", "Boolean", ",", "(", "Type", "*", ")", "0", ")", ";", "Else", "=", "M", ".", "getOrInsertFunction", "(", "ElseIntrinsic", ",", "ReturnStruct", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "Break", "=", "M", ".", "getOrInsertFunction", "(", "BreakIntrinsic", ",", "Int64", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "IfBreak", "=", "M", ".", "getOrInsertFunction", "(", "IfBreakIntrinsic", ",", "Int64", ",", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "ElseBreak", "=", "M", ".", "getOrInsertFunction", "(", "ElseBreakIntrinsic", ",", "Int64", ",", "Int64", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "Loop", "=", "M", ".", "getOrInsertFunction", "(", "LoopIntrinsic", ",", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "EndCf", "=", "M", ".", "getOrInsertFunction", "(", "EndCfIntrinsic", ",", "Void", ",", "Int64", ",", "(", "Type", "*", ")", "0", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "nvptx_init_builtins", "(", "void", ")", "{", "(", "nvptx_builtin_decls", "[", "NVPTX_BUILTIN_", "##", "ID", "]", "\\", "=", "add_builtin_function", "(", "\"__builtin_nvptx_\"", "NAME", ",", "\\", "build_function_type_list", "T", ",", "\\", "NVPTX_BUILTIN_", "##", "ID", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ")", "DEF", "(", "SHUFFLE", ",", "\"shuffle\"", ",", "(", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "SHUFFLELL", ",", "\"shufflell\"", ",", "(", "LLUINT", ",", "LLUINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "WORKER_ADDR", ",", "\"worker_addr\"", ",", "(", "PTRVOID", ",", "ST", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "VECTOR_ADDR", ",", "\"vector_addr\"", ",", "(", "PTRVOID", ",", "ST", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "CMP_SWAP", ",", "\"cmp_swap\"", ",", "(", "UINT", ",", "PTRVOID", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "CMP_SWAPLL", ",", "\"cmp_swapll\"", ",", "(", "LLUINT", ",", "PTRVOID", ",", "LLUINT", ",", "LLUINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "MEMBAR_GL", ",", "\"membar_gl\"", ",", "(", "VOID", ",", "VOID", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "MEMBAR_CTA", ",", "\"membar_cta\"", ",", "(", "VOID", ",", "VOID", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "BAR_RED_AND", ",", "\"bar_red_and\"", ",", "(", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "BAR_RED_OR", ",", "\"bar_red_or\"", ",", "(", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "DEF", "(", "BAR_RED_POPC", ",", "\"bar_red_popc\"", ",", "(", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "UINT", ",", "NULL_TREE", ")", ")", ";", "}", "</s>" ]

[ "Set", "up", "all", "builtin", "functions", "for", "this", "target", "." ]

[ "nvptx", "\"__builtin_nvptx_\"", "\"shuffle\"", "\"shufflell\"", "\"worker_addr\"", "\"vector_addr\"", "\"cmp_swap\"", "\"cmp_swapll\"", "\"membar_gl\"", "\"membar_cta\"", "\"bar_red_and\"", "\"bar_red_or\"", "\"bar_red_popc\"" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "shrinkWrapDisabled", "(", ")", ")", "return", "false", ";", "return", "(", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isSVR4ABI", "(", ")", "&&", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

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

[]

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

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

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

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "RegisterVT", ";", "unsigned", "NumRegisters", ";", "std", "::", "tie", "(", "RegisterVT", ",", "NumRegisters", ")", "=", "handleMaskRegisterForCallingConv", "(", "NumElts", ",", "CC", ",", "Subtarget", ")", ";", "if", "(", "RegisterVT", "!=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ")", "return", "RegisterVT", ";", "}", "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "!", "EnableOldKNLABI", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v16i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::i1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::v32i16", "MVT::v64i8", "MVT::v16i32" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "MINA32Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "MINA32Operand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "MINA32", "MINA32", "MINA32" ]

[]

[ "<s>", "unsigned", "stackAlignment", "(", ")", "const", "{", "return", "isFP64bit", "(", ")", "?", "16", ":", "8", ";", "}", "</s>" ]

[ "The", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "." ]

[ "Mips", "16", "8" ]

[]

[ "<s>", "static", "void", "sparc_asm_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "sparc_leaf_function_p", "==", "current_function_uses_only_leaf_regs", ")", ";", "sparc_output_scratch_registers", "(", "file", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "entry", ",", "which", "boils", "down", "to", "emitting", "the", "necessary", ".register", "directives", "." ]

[ "sparc" ]

[]

[ "<s>", "Register", "CSKYRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "CSKY", "::", "R8", ":", "CSKY", "::", "R14", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::R8", "CSKY::R14" ]

[]

[ "<s>", "static", "bool", "avr_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "PSImode", "==", "mode", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

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

[ "avr" ]

[]

[ "<s>", "static", "tree", "c4x_handle_fntype_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_TYPE", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "c4x", "\"%qs attribute only applies to functions\"" ]

[]

[ "<s>", "static", "bool", "rs6000_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "else", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "(", "mode", "==", "KFmode", "||", "mode", "==", "IFmode", ")", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "scalar_mode_supported_p", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "performAddSubLongCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "performXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMulCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "performIntToFpCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "performIntrinsicCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "performExtendCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "performBitcastCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "performConcatVectorsCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSelectCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSelectCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "performSTORECombine", "(", "N", ",", "DCI", ",", "DAG", ",", "Subtarget", ")", ";", "case", "AArch64ISD", "::", "BRCOND", ":", "return", "performBRCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "AArch64ISD", "::", "CSEL", ":", "return", "performCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ",", "2", ",", "3", ")", ";", "case", "AArch64ISD", "::", "DUP", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "false", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "true", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "aarch64_neon_ld2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld2lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld2r", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3r", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4r", ":", "case", "Intrinsic", "::", "aarch64_neon_st2", ":", "case", "Intrinsic", "::", "aarch64_neon_st3", ":", "case", "Intrinsic", "::", "aarch64_neon_st4", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_st2lane", ":", "case", "Intrinsic", "::", "aarch64_neon_st3lane", ":", "case", "Intrinsic", "::", "aarch64_neon_st4lane", ":", "return", "performNEONPostLDSTCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "default", ":", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "AArch64", "AArch64", "ISD::ADD", "ISD::SUB", "ISD::XOR", "ISD::MUL", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::OR", "ISD::INTRINSIC_WO_CHAIN", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::BITCAST", "ISD::CONCAT_VECTORS", "ISD::SELECT", "ISD::VSELECT", "ISD::STORE", "AArch64ISD::BRCOND", "AArch64ISD::CSEL", "2", "3", "AArch64ISD::DUP", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::aarch64_neon_ld2", "Intrinsic::aarch64_neon_ld3", "Intrinsic::aarch64_neon_ld4", "Intrinsic::aarch64_neon_ld1x2", "Intrinsic::aarch64_neon_ld1x3", "Intrinsic::aarch64_neon_ld1x4", "Intrinsic::aarch64_neon_ld2lane", "Intrinsic::aarch64_neon_ld3lane", "Intrinsic::aarch64_neon_ld4lane", "Intrinsic::aarch64_neon_ld2r", "Intrinsic::aarch64_neon_ld3r", "Intrinsic::aarch64_neon_ld4r", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_st4", "Intrinsic::aarch64_neon_st1x2", "Intrinsic::aarch64_neon_st1x3", "Intrinsic::aarch64_neon_st1x4", "Intrinsic::aarch64_neon_st2lane", "Intrinsic::aarch64_neon_st3lane", "Intrinsic::aarch64_neon_st4lane" ]

[]

[ "<s>", "static", "rtx", "condjump_opposite_condition", "(", "rtx", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "int", "icode", "=", "INSN_CODE", "(", "insn", ")", ";", "rtx", "x", "=", "NULL", ";", "if", "(", "icode", "==", "CODE_FOR_br_true", "||", "icode", "==", "CODE_FOR_br_false", ")", "{", "x", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ";", "if", "(", "icode", "==", "CODE_FOR_br_false", ")", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "{", "rtx", "t", "=", "COND_EXEC_CODE", "(", "pat", ")", ";", "if", "(", "(", "GET_CODE", "(", "t", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "t", ",", "0", ",", "0", ")", ")", "==", "RETURN", ")", "||", "(", "GET_CODE", "(", "t", ")", "==", "UNSPEC", "&&", "XINT", "(", "t", ",", "1", ")", "==", "UNSPEC_REAL_JUMP", ")", "||", "(", "GET_CODE", "(", "t", ")", "==", "SET", "&&", "SET_DEST", "(", "t", ")", "==", "pc_rtx", ")", ")", "x", "=", "COND_EXEC_TEST", "(", "pat", ")", ";", "}", "if", "(", "x", "!=", "NULL_RTX", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "code", "==", "EQ", "?", "NE", ":", "EQ", ",", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Examine", "INSN", ",", "and", "if", "it", "is", "a", "conditional", "jump", "of", "any", "kind", ",", "return", "the", "opposite", "of", "the", "condition", "in", "which", "it", "branches", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

[ "c6x", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "LLVMContext", "&", "getContext", "(", ")", "const", "{", "return", "Context", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "sh_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "to", "==", "SFmode", "&&", "VECTOR_MODE_P", "(", "from", ")", "&&", "GET_MODE_INNER", "(", "from", ")", "==", "SFmode", ")", "return", "optimize", "?", "(", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", ")", ":", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "!=", "GET_MODE_SIZE", "(", "to", ")", ")", "{", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "8", "||", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "reg_classes_intersect_p", "(", "DF_REGS", ",", "rclass", ")", ";", "}", "else", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "reg_classes_intersect_p", "(", "DF_REGS", ",", "rclass", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "class", "of", "registers", "for", "which", "a", "mode", "change", "from", "FROM", "to", "TO", "is", "invalid", "." ]

[ "sh", "8", "8", "8" ]

[]

[ "<s>", "bool", "sh_cannot_change_mode_class", "(", "enum", "machine_mode", "from", ",", "enum", "machine_mode", "to", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "to", "==", "SFmode", "&&", "VECTOR_MODE_P", "(", "from", ")", "&&", "GET_MODE_INNER", "(", "from", ")", "==", "SFmode", ")", "return", "(", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "class", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "!=", "GET_MODE_SIZE", "(", "to", ")", ")", "{", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "8", "||", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "reg_classes_intersect_p", "(", "DF_REGS", ",", "class", ")", ";", "}", "else", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", "return", "reg_classes_intersect_p", "(", "DF_HI_REGS", ",", "class", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "class", "of", "registers", "for", "which", "a", "mode", "change", "from", "FROM", "to", "TO", "is", "invalid", "." ]

[ "sh", "8", "8", "8", "0" ]

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "getStackAddress", "(", "const", "CCValAssign", "&", "VA", ",", "MachineMemOperand", "*", "&", "MMO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "auto", "SPReg", "=", "MIRBuilder", ".", "buildCopy", "(", "p0", ",", "Register", "(", "Mips", "::", "SP", ")", ")", ";", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "auto", "OffsetReg", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "Offset", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "p0", ",", "SPReg", ",", "OffsetReg", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "unsigned", "Size", "=", "alignTo", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ",", "8", ")", "/", "8", ";", "unsigned", "Align", "=", "MinAlign", "(", "TFL", "->", "getStackAlignment", "(", ")", ",", "Offset", ")", ";", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "Mips", "0", "32", "32", "Mips::SP", "8", "8", "0" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "ARG_UNUSED", "(", "subtarget", ")", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "switch", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "NVPTX_BUILTIN_SHUFFLE", ":", "case", "NVPTX_BUILTIN_SHUFFLELL", ":", "return", "nvptx_expand_shuffle", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ")", ";", "case", "NVPTX_BUILTIN_WORKER_ADDR", ":", "return", "nvptx_expand_worker_addr", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ")", ";", "case", "NVPTX_BUILTIN_CMP_SWAP", ":", "case", "NVPTX_BUILTIN_CMP_SWAPLL", ":", "return", "nvptx_expand_cmp_swap", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "static", "bool", "ix86_check_avx256_register", "(", "const_rtx", "exp", ")", "{", "if", "(", "SUBREG_P", "(", "exp", ")", ")", "exp", "=", "SUBREG_REG", "(", "exp", ")", ";", "return", "(", "REG_P", "(", "exp", ")", "&&", "VALID_AVX256_REG_OR_OI_MODE", "(", "GET_MODE", "(", "exp", ")", ")", ")", ";", "}", "</s>" ]

[ "Check", "if", "a", "256bit", "AVX", "register", "is", "referenced", "inside", "of", "EXP", "." ]

[ "i386" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", "&&", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "dmask", ")", "!=", "-", "1", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32_e64", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64_e64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "5", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ",", "Src0", ".", "getNode", "(", ")", "->", "isDivergent", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "9", ">", "Ops", "(", "Node", "->", "op_begin", "(", ")", ",", "Node", "->", "op_end", "(", ")", ")", ";", "Ops", "[", "1", "]", "=", "Src0", ";", "Ops", "[", "3", "]", "=", "Src1", ";", "Ops", "[", "5", "]", "=", "Src2", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32_e64", "AMDGPU::V_DIV_SCALE_F64_e64", "1", "3", "5", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "9", "1", "3", "5", "1" ]

[]

[ "<s>", "bool", "ARM64BranchRelaxation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "if", "(", "!", "BranchRelaxation", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** ARM64BranchRelaxation *****\\n\"", ")", ";", "TII", "=", "(", "const", "ARM64InstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "scanFunction", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks before relaxation\\n\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "relaxBranchInstructions", "(", ")", ")", "MadeChange", "=", "true", ";", "verify", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks after relaxation\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"***** ARM64BranchRelaxation *****\\n\"", "ARM64", "\" Basic blocks before relaxation\\n\"", "\" Basic blocks after relaxation\\n\"" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "*", "MFI", ")", "||", "!", "needsSPWriteback", "(", "MF", ",", "*", "MFI", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "InsertAddr", "=", "InsertPt", ";", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "InsertAddr", "=", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ";", "}", "writeSPToMemory", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertAddr", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::FP32", "WebAssembly::SP32" ]

[]

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

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

[ "ARM64" ]

[]