Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "if", "(", "TARGET_AVX512F", "&&", "TARGET_EVEX512", ")", "clonei", "->", "vecsize_mangle", "=", "'", "e", "'", ";" ]

[ "static", "int", "ix86_simd_clone_compute_vecsize_and_simdlen", "(", "struct", "cgraph_node", "*", "node", ",", "struct", "cgraph_simd_clone", "*", "clonei", ",", "tree", "base_type", ",", "int", "num", ",", "bool", "explicit_p", ")", "{", "int", "ret", "=", "<NUM_LIT>", ";", "if", "(", "clonei", "->", "simdlen", "&&", "(", "clonei", "->", "simdlen", "<", "<NUM_LIT>", "||", "clonei", "->", "simdlen", ">", "<NUM_LIT>", "||", "(", "clonei", "->", "simdlen", "&", "(", "clonei", "->", "simdlen", "-", "<NUM_LIT>", ")", ")", "!=", "<NUM_LIT>", ")", ")", "{", "if", "(", "explicit_p", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "unsupported simdlen %wd", "<STR_LIT>", ",", "clonei", "->", "simdlen", ".", "to_constant", "(", ")", ")", ";", "return", "<NUM_LIT>", ";", "}", "tree", "ret_type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", "->", "decl", ")", ")", ";", "if", "(", "TREE_CODE", "(", "ret_type", ")", "!=", "VOID_TYPE", ")", "switch", "(", "TYPE_MODE", "(", "ret_type", ")", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "ret_type", ")", ")", "break", ";", "default", ":", "if", "(", "explicit_p", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "unsupported return type %qT for simd", "<STR_LIT>", ",", "ret_type", ")", ";", "return", "<NUM_LIT>", ";", "}", "tree", "t", ";", "int", "i", ";", "tree", "type_arg_types", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "node", "->", "decl", ")", ")", ";", "bool", "decl_arg_p", "=", "(", "node", "->", "definition", "||", "type_arg_types", "==", "NULL_TREE", ")", ";", "for", "(", "t", "=", "(", "decl_arg_p", "?", "DECL_ARGUMENTS", "(", "node", "->", "decl", ")", ":", "type_arg_types", ")", ",", "i", "=", "<NUM_LIT>", ";", "t", "&&", "t", "!=", "void_list_node", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ",", "i", "++", ")", "{", "tree", "arg_type", "=", "decl_arg_p", "?", "TREE_TYPE", "(", "t", ")", ":", "TREE_VALUE", "(", "t", ")", ";", "switch", "(", "TYPE_MODE", "(", "arg_type", ")", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "arg_type", ")", ")", "break", ";", "default", ":", "if", "(", "clonei", "->", "args", "[", "i", "]", ".", "arg_type", "==", "SIMD_CLONE_ARG_TYPE_UNIFORM", ")", "break", ";", "if", "(", "explicit_p", ")", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "unsupported argument type %qT for simd", "<STR_LIT>", ",", "arg_type", ")", ";", "return", "<NUM_LIT>", ";", "}", "}", "if", "(", "!", "TREE_PUBLIC", "(", "node", "->", "decl", ")", "||", "!", "explicit_p", ")", "{" ]

[ "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "Type", "*", "MemType", "=", "LI", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "LI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "}", "else", "{" ]

[ "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "}", "Register", "LongBranchReservedReg", "=", "MFI", "->", "getLongBranchReservedReg", "(", ")", ";", "if", "(", "LongBranchReservedReg", ")", "reserveRegisterTuples", "(", "Reserved", ",", "LongBranchReservedReg", ")", ";", "MCRegister", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "MCRegister", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "MCRegister", "BasePtrReg", "=", "getBaseRegister", "(", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "BasePtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "BasePtrReg", ")", ")", ";", "}", "Register", "ExecCopyReg", "=", "MFI", "->", "getSGPRForEXECCopy", "(", ")", ";", "if", "(", "ExecCopyReg", ")", "reserveRegisterTuples", "(", "Reserved", ",", "ExecCopyReg", ")", ";", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "MaxNumAGPRs", "=", "MaxNumVGPRs", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "{", "if", "(", "MFI", "->", "usesAGPRs", "(", "MF", ")", ")", "{", "MaxNumVGPRs", "/", "=", "<NUM_LIT>", ";", "MaxNumAGPRs", "=", "MaxNumVGPRs", ";", "}", "else", "{", "if", "(", "MaxNumVGPRs", ">", "TotalNumVGPRs", ")", "{", "MaxNumAGPRs", "=", "MaxNumVGPRs", "-", "TotalNumVGPRs", ";", "MaxNumVGPRs", "=", "TotalNumVGPRs", ";", "}", "else", "MaxNumAGPRs", "=", "<NUM_LIT>", ";", "}", "}", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "if", "(", "ST", ".", "hasMAIInsts", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "MaxNumAGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "AGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}" ]

[ ":", "VF_SF_AVX512VL" ]

[ "(", "match_operand", ":", "VF_SF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_SF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg" ]

[ ";" ]

[ "rtx", "aarch_gen_bti_c", "(", "void", ")", "{", "return", "gen_bti_nop", "(", ")" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "base", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "(", "LO7", "$", "I", ")", ",", "v256f64", ":", "$", "vz", ",", "i32", ":", "$", "vl", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vminsl_vsvl", "simm7", ":", "$", "I", ",", "v256f64", ":", "$", "vz", ",", "i32", ":", "$", "vl", ")", ",", "(", "VMINSLivl" ]

[ "<FIXS>", "(", "ins", "DPR", ":", "$", "src", ")", ",", "itin", ",", "OpcodeStr", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<FIXE>", "<FIXS>", "(", "ins", "QPR", ":", "$", "src", ")", ",", "itin", ",", "OpcodeStr", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<FIXE>" ]

[ "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "Intrinsic", "IntOp", ">", ":", "N2V", "op24_23", ",", "op21_20", ",", "op19_18", ",", "op17_16", ",", "op11_7", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "DPR", ":", "$", "dst", ")", ",", "<BUGS>", "(", "ins", "DPR", ":", "$", "src", ")", ",", "itin", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "<BUGE>", "[", "(", "set", "DPR", ":", "$", "dst", ",", "(", "ResTy", "(", "IntOp", "(", "OpTy", "DPR", ":", "$", "src", ")", ")", ")", ")", "]", ">", ";", "class", "N2VQInt", "bits", "<NUM_LIT>", ">", "op24_23", ",", "bits", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<NUM_LIT>", ">", "op19_18", ",", "bits", "<NUM_LIT>", ">", "op17_16", ",", "bits", "<NUM_LIT>", ">", "op11_7", ",", "bit", "op4", ",", "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "Intrinsic", "IntOp", ">", ":", "N2V", "op24_23", ",", "op21_20", ",", "op19_18", ",", "op17_16", ",", "op11_7", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "QPR", ":", "$", "dst", ")", ",", "<BUGS>", "(", "ins", "QPR", ":", "$", "src", ")", ",", "itin", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "<BUGE>", "[", "(", "set", "QPR", ":", "$", "dst", ",", "(", "ResTy", "(", "IntOp", "(", "OpTy", "QPR", ":", "$", "src", ")", ")", ")", ")", "]", ">", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "cc0", ")", "(", "ne", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "OR", ";" ]

[ "inline", "static", "AluCode", "isdToLanaiAluCode", "(", "ISD", "::", "NodeType", "Node_type", ")", "{", "switch", "(", "Node_type", ")", "{", "case", "ISD", "::", "ADD", ":", "return", "AluCode", "::", "ADD", ";", "case", "ISD", "::", "ADDE", ":", "return", "AluCode", "::", "ADDC", ";", "case", "ISD", "::", "SUB", ":", "return", "AluCode", "::", "SUB", ";", "case", "ISD", "::", "SUBE", ":", "return", "AluCode", "::", "SUBB", ";", "case", "ISD", "::", "AND", ":", "return", "AluCode", "::", "AND", ";", "case", "ISD", "::", "OR", ":", "return", "AluCode", "::" ]

[ "if", "(", "!", "Changed", ")", "{" ]

[ "Value", "*", "Simplifier", "::", "simplify", "(", "Context", "&", "C", ")", "{", "WorkListType", "Q", ";", "Q", ".", "push_back", "(", "C", ".", "Root", ")", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "const", "unsigned", "Limit", "=", "SimplifyLimit", ";", "while", "(", "!", "Q", ".", "empty", "(", ")", ")", "{", "if", "(", "Count", "++", ">=", "Limit", ")", "break", ";", "Instruction", "*", "U", "=", "dyn_cast", "<", "Instruction", ">", "(", "Q", ".", "pop_front_val", "(", ")", ")", ";", "if", "(", "!", "U", "||", "U", "->", "getParent", "(", ")", "||", "!", "C", ".", "Used", ".", "count", "(", "U", ")", ")", "continue", ";", "bool", "Changed", "=", "false", ";", "for", "(", "Rule", "&", "R", ":", "Rules", ")", "{", "Value", "*", "W", "=", "R", ".", "Fn", "(", "U", ",", "C", ".", "Ctx", ")", ";", "if", "(", "!", "W", ")", "continue", ";", "Changed", "=", "true", ";", "C", ".", "record", "(", "W", ")", ";", "C", ".", "replace", "(", "U", ",", "W", ")", ";", "Q", ".", "push_back", "(", "C", ".", "Root", ")", ";", "break", ";", "}" ]

[ "]", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR" ]

[ "UNSPECV_ATOMIC_LDOP_XOR" ]

[ "UNSPECV_LX", "UNSPECV_SX", "UNSPECV_LDA", "UNSPECV_STL", "UNSPECV_ATOMIC_CMPSW", "UNSPECV_ATOMIC_EXCHG", "UNSPECV_ATOMIC_CAS", "UNSPECV_ATOMIC_SWP", "UNSPECV_ATOMIC_OP", "UNSPECV_ATOMIC_LDOP", "UNSPECV_ATOMIC_LDOP_OR", "UNSPECV_ATOMIC_LDOP_BIC" ]

[ "<FIXS>", "GATHER", ",", "SCATTER", ",", "PREFETCH", ",", "RDSEED", ",", "RDRAND", ",", "RDPMC", ",", "RDTSC", ",", "XTEST", "<FIXE>" ]

[ "}", "enum", "IntrinsicType", "{", "<BUGS>", "GATHER", ",", "SCATTER", ",", "PREFETCH", ",", "RDSEED", ",", "RDRAND", ",", "RDTSC", ",", "XTEST", "<BUGE>", "}", ";", "struct", "IntrinsicData", "{" ]

[ ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ",", "const", "TargetMachine", "&", "TM", ")", "{" ]

[ "void", "ARM64_ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx" ]

[ "<NUM_LIT>", "]", ")" ]

[ "{", "machine_mode", "mode", "=", "<", "VALL_F16", ":", "MODE", ">", "mode", "rtx", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "operands", "[" ]

[ "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i1", ",", "Custom", ")", ";" ]

[ "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "v2i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "v4i32", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i32", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i32", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v8i32", ",", "MVT", "::", "v8i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v16i32", ",", "MVT", "::", "v16i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v32i32", ",", "MVT", "::", "v32i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v8i32", ",", "MVT", "::", "v8i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v16i32", ",", "MVT", "::", "v16i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v32i32", ",", "MVT", "::", "v32i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETO", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUO", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETOLT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETOLE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETONE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUEQ", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULE", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLE", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETLT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULE", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETULT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v4i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v2i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BRCOND", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FSUB", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "f32", ",", "Expand", ")", ";" ]

[ "<FIXS>", "abort", "(", ")", ";", "<FIXE>" ]

[ "break", ";", "default", ":", "<BUGS>", "abort", "(", ")", ";", "<BUGE>", "}", "return", "buf", ";", "}" ]

[ ",", "mode", ")" ]

[ "return", "(", "register_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "mode", ")", "&", "&", "small_int_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "mode", ")", "&", "&", "small_int_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")" ]

[ "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVST2", "]", ">", "{" ]

[ "class", "VST1Q", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "VecListDPair", ":", "$", "Vd", ")", ",", "IIC_VST1x2", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", "," ]

[ "setReg", "(", "DestReg", ")", ";" ]

[ "MIB", ".", "addReg", "(", "From", ")", ";", "MIB", ".", "addReg", "(", "From", ")", ";", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MIB", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MIB", ".", "addReg", "(", "To", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Inserted VMOV: ", "<STR_LIT>", "<<", "*", "MIB", ")", ";", "}", ";", "for", "(", "auto", "&", "Reduction", ":", "LoLoop", ".", "Reductions", ")", "{", "MachineInstr", "&", "Copy", "=", "Reduction", "->", "Copy", ";", "MachineInstr", "&", "Reduce", "=", "Reduction", "->", "Reduce", ";", "Register", "DestReg", "=", "Copy", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reduction", "->", "Init", ")", "{", "MachineInstr", "*", "Init", "=", "Reduction", "->", "Init", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Init", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "Init", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "MO", ".", "isTied", "(", ")", "&&", "Init", "->", "findTiedOperandIdx", "(", "i", ")", "==", "<NUM_LIT>", ")", "Init", "->", "getOperand", "(", "i", ")", ".", "setReg", "(", "DestReg", ")", ";", "}", "Init", "->", "getOperand", "(", "<NUM_LIT>", ")", "." ]

[ "DONE" ]

[ "(", "match_operand", ":", "ALLI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec_volatile", ":", "ALLI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_ATOMIC_OP", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "aarch64_split_atomic_op", "(", "NOT", ",", "NULL", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "}" ]

[ "WDC_LOG", "(", "<STR_LIT>", "WDC_TODO - Unimplemented method called", "<STR_LIT>", ")", ";", "return", "false", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ "}" ]

[ "report_fatal_error", "(", "<STR_LIT>", "emitEpilogue doesn't support framepointer-less functions", "<STR_LIT>", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "MMIXRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "MachineBasicBlock", "::", "iterator", "LastFrameDestroy", "=", "MBBI", ";", "size_t", "CalleeSavedSize", "=", "getCalleeSavedSize", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "std", "::", "advance", "(", "LastFrameDestroy", ",", "-", "CalleeSavedSize", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";" ]

[ ")", "{" ]

[ "void", "setCPUTopSavedRegOff", "(", "int", "Off" ]

[ "<FIXS>", "error", "(", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "offset", "=", "<NUM_LIT>", "}", "else", "<BUGS>", "error", "(", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "mask", "=", "GEN_INT", "(", "~", "(", "<NUM_LIT>", "<NUM_LIT>", "*", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "offset", ")", ")", ")", "priority", "=", "GEN_INT", "(", "(", "int", ")", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "Form231", "]", ";" ]

[ "unsigned", "get231Opcode", "(", ")", "const", "{", "return", "Opcodes", "[" ]

[ ")", "$", "Rn", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "round", "f16", ":", "$", "Rn", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "INST", "#", "UWHr" ]

[ "<FIXS>", "}", "else", "if", "(", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "BlockAddressSDNode", ">", "(", "N0", ")", ")", "{", "X86ISelAddressMode", "Backup", "=", "AM", ";", "AM", ".", "BlockAddr", "=", "BA", "->", "getBlockAddress", "(", ")", ";", "AM", ".", "SymbolFlags", "=", "BA", "->", "getTargetFlags", "(", ")", ";", "if", "(", "FoldOffsetIntoAddress", "(", "BA", "->", "getOffset", "(", ")", ",", "AM", ")", ")", "{", "AM", "=", "Backup", ";", "return", "true", ";", "}", "}", "elsellvm_unreachable", "(", "<STR_LIT>", "Unhandled symbol reference node.", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "}", "else", "if", "(", "JumpTableSDNode", "*", "J", "=", "dyn_cast", "JumpTableSDNode", ">", "(", "N0", ")", ")", "{", "AM", ".", "JT", "=", "J", "->", "getIndex", "(", ")", ";", "AM", ".", "SymbolFlags", "=", "J", "->", "getTargetFlags", "(", ")", ";", "<BUGS>", "}", "else", "{", "AM", ".", "BlockAddr", "=", "cast", "BlockAddressSDNode", ">", "(", "N0", ")", "->", "getBlockAddress", "(", ")", ";", "AM", ".", "SymbolFlags", "=", "cast", "BlockAddressSDNode", ">", "(", "N0", ")", "->", "getTargetFlags", "(", ")", ";", "}", "<BUGE>", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "AM", ".", "setBaseReg", "(", "CurDAG", "->", "getRegister", "(", "X86", "::", "RIP", ",", "MVT", "::", "i64", ")", ")", ";" ]

[ "int", "neon_immediate_valid_for_logic", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "inverse", ",", "rtx", "*", "modconst", ",", "int", "*", "elementwidth", ")", "{", "rtx", "tmpconst", ";", "int", "tmpwidth", ";", "int", "retval", "=", "simd_valid_immediate", "(", "op", ",", "mode", ",", "inverse", ",", "&", "tmpconst", ",", "&", "tmpwidth", ")", ";", "if", "(", "retval", "<", "<NUM_LIT>", "||", "retval", ">", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "modconst", ")", "*", "modconst", "=", "tmpconst", ";", "if", "(", "elementwidth", ")", "*", "elementwidth", "=", "tmpwidth", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "legal", "for", "use", "in", "a", "VORR", "or", "VBIC", "instruction", ".", "If", "the", "immediate", "is", "valid", ",", "write", "a", "constant", "suitable", "for", "using", "as", "an", "operand", "to", "VORR/VBIC/VAND/VORN", "to", "*", "MODCONST", "and", "the", "corresponding", "element", "width", "to", "*", "ELEMENTWIDTH", ".", "See", "neon_valid_immediate", "for", "description", "of", "INVERSE", "." ]

[ "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "AbsoluteSet", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "bool", "HexagonInstrInfo", "::", "canExecuteInBundle", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Second", ")", "const", "{", "if", "(", "Second", ".", "mayStore", "(", ")", "&&", "First", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "S2_allocframe", ")", "{", "const", "MachineOperand", "&", "Op", "=", "Second", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "Hexagon", "::", "R29", ")", "return", "true", ";", "}", "if", "(", "DisableNVSchedule", ")", "return", "false", ";", "if", "(", "mayBeNewStore", "(", "Second", ")", ")", "{", "const", "MachineOperand", "&", "Stored", "=", "Second", ".", "getOperand", "(", "Second", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "Stored", ".", "isReg", "(", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "First", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "Op", "=", "First", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isDef", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "Stored", ".", "getReg", "(", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

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

[ "Register", ")", ")", ";" ]

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "Fail", ";", "unsigned", "Register", "=", "FPR8DecoderTable", "[", "RegNo", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(" ]

[ ";" ]

[ "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "Count", ";", "if", "(", "Count", "&&", "(", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jump", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "Malformed basic block: unconditional branch not last", "<STR_LIT>", ")", ";", "MBB", ".", "erase", "(", "&", "MBB", ".", "back", "(", ")", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", ")", ";" ]

[ "unsigned", "Size", "=", "<NUM_LIT>", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "Value", ")", "&&", "<STR_LIT>", "Value does not fit in the Fixup field", "<STR_LIT>", ")", ";" ]

[ "|", "|", "TARGET_SH2A_DOUBLE", ")" ]

[ "(", "float_truncate", ":", "SF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_SH4" ]

[ "static", "void", "output_movsi", "(", "rtx", "operands", "[", "<NUM_LIT>", "]", ")", "{", "output_asm_insn", "(", "singlemove_string", "(", "operands", ")", ",", "operands", ")", ";", "}" ]

[ "Output", "the", "best", "assembler", "insn", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "." ]

[ "ret", ".", "tcb_gbr_offset", "=", "integral_argument", "(", "offset_str", ".", "c_str", "(", ")", ")", ";" ]

[ "model_cdef_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "<STR_LIT>", "SOFT_GUSA", "<STR_LIT>", ";", "model_cdef_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "<STR_LIT>", "HARD_LLCS", "<STR_LIT>", ";", "model_cdef_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "<STR_LIT>", "SOFT_TCB", "<STR_LIT>", ";", "model_cdef_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "<STR_LIT>", "SOFT_IMASK", "<STR_LIT>", ";", "sh_atomic_model", "ret", ";", "ret", ".", "type", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ret", ".", "name", "=", "model_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ";", "ret", ".", "cdef_name", "=", "model_cdef_names", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ";", "ret", ".", "strict", "=", "false", ";", "ret", ".", "tcb_gbr_offset", "=", "-", "<NUM_LIT>", ";", "if", "(", "str", "==", "NULL", "||", "*", "str", "==", "'", "\\0", "'", ")", "return", "ret", ";", "std", "::", "vector", "<", "std", "::", "string", ">", "tokens", ";", "for", "(", "std", "::", "stringstream", "ss", "(", "str", ")", ";", "ss", ".", "good", "(", ")", ";", ")", "{", "tokens", ".", "push_back", "(", "std", "::", "string", "(", ")", ")", ";", "std", "::", "getline", "(", "ss", ",", "tokens", ".", "back", "(", ")", ",", "'", ",", "'", ")", ";", "}", "if", "(", "tokens", ".", "empty", "(", ")", ")", "err_ret", "(", "<STR_LIT>", "invalid atomic model option", "<STR_LIT>", ")", ";", "{", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "<STR_LIT>", "::", "<STR_LIT>", ";", "++", "i", ")", "if", "(", "tokens", ".", "front", "(", ")", "==", "model_names", "[", "i", "]", ")", "{", "ret", ".", "type", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "i", ";", "ret", ".", "name", "=", "model_names", "[", "i", "]", ";", "ret", ".", "cdef_name", "=", "model_cdef_names", "[", "i", "]", ";", "goto", "got_mode_name", ";", "}", "err_ret", "(", "<STR_LIT>", "invalid atomic model name %qs", "<STR_LIT>", ",", "tokens", ".", "front", "(", ")", ".", "c_str", "(", ")", ")", ";", "got_mode_name", ":", ";", "}", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "tokens", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "tokens", "[", "i", "]", "==", "<STR_LIT>", "strict", "<STR_LIT>", ")", "ret", ".", "strict", "=", "true", ";", "else", "if", "(", "!", "tokens", "[", "i", "]", ".", "compare", "(", "<NUM_LIT>", ",", "strlen", "(", "<STR_LIT>", "gbr-offset=", "<STR_LIT>", ")", ",", "<STR_LIT>", "gbr-offset=", "<STR_LIT>", ")", ")", "{", "std", "::", "string", "offset_str", "=", "tokens", "[", "i", "]", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "gbr-offset=", "<STR_LIT>", ")", ")", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr" ]

[ "}" ]

[ "Results", ".", "push", "(", "Hexagon", "::", "V6_vd0", ",", "ByteTy", ",", "{", "}", ")", ";", "Results", ".", "push", "(", "Hexagon", "::", "V6_veqb", ",", "BoolTy", ",", "{", "OpRef", "(", "B", ")", ",", "OpRef", "::", "res", "(", "-", "<NUM_LIT>", ")", "}", ")", ";", "Results", ".", "push", "(", "Hexagon", "::", "V6_vmux", ",", "ByteTy", ",", "{", "OpRef", "::", "res", "(", "-", "<NUM_LIT>", ")", ",", "Vb", ",", "Va", "}", ")", ";", "return", "OpRef", "::", "res", "(", "Results", ".", "top", "(", ")", ")", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "def", "A2_pxorfnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_3op", ">", ",", "Enc_ea4c54", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "<STR_LIT>", "Return value without a vreg", "<STR_LIT>", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "ArgInfo", "OrigRetInfo", "(", "VRegs", ",", "Val", "->", "getType", "(", ")", ",", "<NUM_LIT>", ")", ";", "setArgFlags", "(", "OrigRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "SplitRetInfos", ";", "splitToValueTypes", "(", "OrigRetInfo", ",", "SplitRetInfos", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "X86OutgoingValueAssigner", "Assigner", "(", "RetCC_X86", ")", ";", "X86OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "Handler", ",", "Assigner", ",", "SplitRetInfos", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}" ]

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

[ "::", "v4i32", ",", "FPTrunc", ")", ";" ]

[ "}", "return", "true", ";", "}", ";", "if", "(", "auto", "*", "Shuffle", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "Trunc", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "if", "(", "isVMOVNShuffle", "(", "Shuffle", ",", "false", ")", "||", "isVMOVNShuffle", "(", "Shuffle", ",", "true", ")", ")", "return", "SDValue", "(", ")", ";", "LLVMContext", "&", "C", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "SDLoc", "DL", "(", "St", ")", ";", "SDValue", "Ch", "=", "St", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "St", "->", "getBasePtr", "(", ")", ";", "Align", "Alignment", "=", "St", "->", "getOriginalAlign", "(", ")", ";", "MachineMemOperand", "::", "Flags", "MMOFlags", "=", "St", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ";", "AAMDNodes", "AAInfo", "=", "St", "->", "getAAInfo", "(", ")", ";", "EVT", "NewFromVT", "=", "EVT", "::", "getVectorVT", "(", "C", ",", "FromEltVT", ",", "NumElements", ")", ";", "EVT", "NewToVT", "=", "EVT", "::", "getVectorVT", "(", "C", ",", "EVT", "::", "getIntegerVT", "(", "C", ",", "ToEltVT", ".", "getSizeInBits", "(", ")", ")", ",", "NumElements", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Stores", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "FromVT", ".", "getVectorNumElements", "(", ")", "/", "NumElements", ";", "i", "++", ")", "{", "unsigned", "NewOffset", "=", "i", "*", "NumElements", "*", "ToEltVT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "SDValue", "NewPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "DL", ",", "BasePtr", ",", "TypeSize", "::", "Fixed", "(", "NewOffset", ")", ")", ";", "SDValue", "Extract", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "NewFromVT", ",", "Trunc", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "i", "*", "NumElements", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "FPTrunc", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8f16", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v8f16", ")", ",", "Extract", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Extract", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RST", ";" ]

[ "class", "X_FRT5_XO2_XO3_RM2_X10", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "xo1", ",", "bits", "<", "<NUM_LIT>", ">", "xo2", ",", "bits", "<", "<NUM_LIT>", ">", "xo", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ",", "InstrItinClass", "itin", ",", "list", "<", "dag", ">", "pattern", ">", ":", "XForm_base_r3xo", "<", "opcode", ",", "xo", ",", "OOL", ",", "IOL", ",", "asmstr", ",", "itin", ",", "pattern", ">", "{", "let", "Pattern", "=", "pattern", ";", "bits", "<", "<NUM_LIT>", ">", "RM", ";" ]

[ "MachineBasicBlock", "::", "iterator", "UPTFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "I", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "}" ]

[ "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", ")", "." ]

[ "break", ";" ]

[ "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "return", "Subtarget", "->", "hasFP32Denormals", "(", ")", "&&", "Subtarget", "->", "hasFastFMAF32", "(", ")", ";", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":" ]

[ "}", "else", "if", "(", "DestVT", ".", "bitsGT", "(", "MVT", "::", "f64", ")", ")", "{" ]

[ "SDValue", "Or", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "MVT", "::", "v2i64", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v2i64", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Load", ")", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v2i64", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Bias", ")", ")", ")", ";", "Or", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "f64", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Or", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "MVT", "::", "f64", ",", "Or", ",", "Bias", ")", ";", "EVT", "DestVT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "DestVT", ".", "bitsLT", "(", "MVT", "::", "f64", ")", ")", "{", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "DestVT", ",", "Sub", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "def", "A2_addsph", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "&", "dl", ")", "{" ]

[ "inline", "SDValue", "getI32Imm", "(", "unsigned", "Imm", ",", "const", "SDLoc" ]

[ ";" ]

[ "static", "SDValue", "LowerSDIV_v4i16", "(", "SDValue", "N0", ",", "SDValue", "N1", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SDValue", "N2", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "MVT", "::", "v4i32", ",", "N0", ")", ";", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "MVT", "::", "v4i32", ",", "N1", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N0", ")", ";", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N1", ")", ";", "N2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "dl", ",", "MVT", "::", "v4f32", ",", "DAG", ".", "getConstant", "(", "Intrinsic", "::", "arm_neon_vrecpe", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "N1", ")", ";", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "dl", ",", "MVT", "::", "v4f32", ",", "DAG", ".", "getConstant", "(", "Intrinsic", "::", "arm_neon_vrecps", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "N1", ",", "N2", ")", ";", "N2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N1", ",", "N2", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N0", ",", "N2", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v4i32", ",", "N0", ")", ";", "N1", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "v4i32", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "v4i32", ",", "N0", ",", "N1", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N0", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_TO_SINT", ",", "dl", ",", "MVT", "::", "v4i32", ",", "N0", ")", ";", "N0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "v4i16", ",", "N0", ")", ";", "return", "N0" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m256i", "_", "_", "lasx_xvhaddw_h_b", "(", "_", "_", "m256i", "_", "<NUM_LIT>", ",", "_", "_", "m256i", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvhaddw_h_b", "(", "(", "v32i8", ")", "_", "<NUM_LIT>", ",", "(", "v32i8", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "Align", "==", "<NUM_LIT>", ")", "{" ]

[ "if", "(", "CFP", "->", "isNullValue", "(", ")", ")", "return", "fastMaterializeFloatZero", "(", "CFP", ")", ";", "CodeModel", "::", "Model", "CM", "=", "TM", ".", "getCodeModel", "(", ")", ";", "if", "(", "CM", "!=", "CodeModel", "::", "Small", "&&", "CM", "!=", "CodeModel", "::", "Large", ")", "return", "<NUM_LIT>", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "MVT", "::", "f32", ":", "if", "(", "X86ScalarSSEf32", ")", "{", "Opc", "=", "Subtarget", "->", "hasAVX", "(", ")", "?", "X86", "::", "VMOVSSrm", ":", "X86", "::", "MOVSSrm", ";", "RC", "=", "&", "X86", "::", "FR32RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp32m", ";", "RC", "=", "&", "X86", "::", "RFP32RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "X86ScalarSSEf64", ")", "{", "Opc", "=", "Subtarget", "->", "hasAVX", "(", ")", "?", "X86", "::", "VMOVSDrm", ":", "X86", "::", "MOVSDrm", ";", "RC", "=", "&", "X86", "::", "FR64RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp64m", ";", "RC", "=", "&", "X86", "::", "RFP64RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f80", ":", "return", "<NUM_LIT>", ";", "}", "unsigned", "Align", "=", "DL", ".", "getPrefTypeAlignment", "(", "CFP", "->", "getType", "(", ")", ")", ";" ]

[ "OpNode", "(", "extract_high_v4i32", "V128", ":", "$", "Rn", ")", ",", "(", "extract_high_v4i32", "V128", ":", "$", "Rm", ")", ")", ")", "]", ">", ";" ]

[ "def", "v4i32_v2i64", ":", "BaseSIMDDifferentThreeVector", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128", ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i64", "V128", ":", "$", "Rd", ")", ",", "(" ]

[ "}" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ ";" ]

[ "static", "<STR_LIT>", "::", "<STR_LIT>", "intCCToAVRCC", "(", "ISD", "::", "CondCode", "CC", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown condition code!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETEQ", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETNE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string" ]

[ ")", "{" ]

[ "SDValue", "SITargetLowering", "::", "performMemSDNodeCombine", "(", "MemSDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SDValue", "Ptr", "=", "N", "->", "getBasePtr", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "SL", "(", "N", ")", ";", "if", "(", "Ptr", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "SDValue", "NewPtr", "=", "performSHLPtrCombine", "(", "Ptr", ".", "getNode", "(", ")", ",", "N", "->", "getAddressSpace", "(", ")", ",", "N", "->", "getMemoryVT", "(", ")", ",", "DCI", ")", ";", "if", "(", "NewPtr" ]

[ ")", "]", ")" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "It", ";" ]

[ "MachineBasicBlock", "::", "reverse_iterator", "It", "=", "MBB", "->", "rbegin", "(", ")", ";", "MachineInstr", "*", "MI", "=", "&", "*" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=" ]

[ ">", ";" ]

[ "def", "IntCondVariantNH", ":", "CondVariant", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>" ]

[ "<FIXS>", "TII", "->", "get", "(", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32_e64", ")", ",", "Tmp", ")", ".", "addReg", "(", "Vgpr", ")", ";", "<FIXE>" ]

[ "}", "auto", "Tmp", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "AGPR_32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "<BUGS>", "TII", "->", "get", "(", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32", ")", ",", "Tmp", ")", ".", "addReg", "(", "Vgpr", ")", ";", "<BUGE>", "B", ".", "addReg", "(", "Tmp", ")", ";", "}" ]

[ "frame", "->", "acc_mask", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "TARGET_MIPS16", ")", "frame", "->", "hard_frame_pointer_offset", "=", "frame", "->", "args_size", ";", "cfun", "->", "machine", "->", "global_pointer", "=", "mips_global_pointer", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "global_pointer", "!=", "GLOBAL_POINTER_REGNUM", ")", "df_set_regs_ever_live", "(", "GLOBAL_POINTER_REGNUM", ",", "false", ")", ";", "offset", "=", "frame", "->", "args_size", "+", "frame", "->", "cprestore_size", ";", "frame", "->", "var_size", "=", "MIPS_STACK_ALIGN", "(", "size", ")", ";", "offset", "+=", "frame", "->", "var_size", ";", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "if", "(", "mips_save_reg_p", "(", "regno", ")", ")", "{", "frame", "->", "num_gp", "++", ";", "frame", "->", "mask", "|=", "<NUM_LIT>", "<<", "(", "regno", "-", "GP_REG_FIRST", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "{", "frame", "->", "num_gp", "++", ";", "frame", "->", "mask", "|=", "<NUM_LIT>", "<<", "(", "EH_RETURN_DATA_REGNO", "(", "i", ")", "-", "GP_REG_FIRST", ")", ";", "}", "if", "(", "GENERATE_MIPS16E_SAVE_RESTORE", ")", "{", "mips16e_mask_registers", "(", "&", "frame", "->", "mask", ",", "mips16e_s2_s8_regs", ",", "ARRAY_SIZE", "(", "mips16e_s2_s8_regs", ")", ",", "&", "frame", "->", "num_gp", ")", ";", "mips16e_mask_registers", "(", "&", "frame", "->", "mask", ",", "mips16e_a0_a3_regs", ",", "ARRAY_SIZE", "(", "mips16e_a0_a3_regs", ")", ",", "&", "frame", "->", "num_gp", ")", ";", "}", "if", "(", "frame", "->", "num_gp", ">", "<NUM_LIT>", ")", "{", "offset", "+=", "MIPS_STACK_ALIGN", "(", "frame", "->", "num_gp", "*", "UNITS_PER_WORD", ")", ";", "frame", "->", "gp_sp_offset", "=", "offset", "-", "UNITS_PER_WORD", ";", "}", "if", "(", "TARGET_HARD_FLOAT", ")", "for", "(", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "+=", "MAX_FPRS_PER_FMT", ")", "if", "(", "mips_save_reg_p", "(", "regno", ")", ")", "{", "frame", "->", "num_fp", "+=", "MAX_FPRS_PER_FMT", ";", "frame", "->", "fmask", "|=", "~", "(", "~", "<NUM_LIT>", "U", "<<", "MAX_FPRS_PER_FMT", ")", "<<", "(", "regno", "-", "FP_REG_FIRST", ")", ";", "}", "if", "(", "frame", "->", "num_fp", ">", "<NUM_LIT>", ")", "{", "offset", "+=", "MIPS_STACK_ALIGN", "(", "frame", "->", "num_fp", "*", "UNITS_PER_FPREG", ")", ";", "frame", "->", "fp_sp_offset", "=", "offset", "-", "UNITS_PER_HWFPVALUE", ";", "}", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "{", "if", "(", "mips_save_reg_p", "(", "LO_REGNUM", ")", "||", "mips_save_reg_p", "(", "HI_REGNUM", ")", ")", "{", "frame", "->", "num_acc", "++", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_monitorx", "(", "void", "const", "*", "_", "_", "P", ",", "unsigned", "int", "_", "_", "E", ",", "unsigned", "int", "_", "_", "H", ")", "{", "_", "_", "builtin_ia32_monitorx", "(", "_", "_", "P", ",", "_", "_", "E", ",", "_", "_", "H", ")", ";" ]

[ "NewR", ")", ",", "RC", ")", ";" ]

[ "unsigned", "SW", "=", "SC", ".", "width", "(", ")", ";", "if", "(", "SW", "<", "RW", "||", "(", "SW", "%", "RW", ")", "!=", "<NUM_LIT>", ")", "continue", ";", "unsigned", "Off", "=", "<NUM_LIT>", ";", "while", "(", "Off", "<=", "SW", "-", "Len", ")", "{", "unsigned", "OE", "=", "(", "Off", "+", "Len", ")", "/", "RW", ";", "if", "(", "OE", "!=", "Off", "/", "RW", ")", "{", "Off", "=", "OE", "*", "RW", ";", "continue", ";", "}", "if", "(", "HBS", "::", "isEqual", "(", "RC", ",", "<NUM_LIT>", ",", "SC", ",", "Off", ",", "Len", ")", ")", "break", ";", "++", "Off", ";", "}", "if", "(", "Off", ">", "SW", "-", "Len", ")", "continue", ";", "unsigned", "ExtOpc", "=", "<NUM_LIT>", ";", "if", "(", "Off", "==", "<NUM_LIT>", ")", "{", "if", "(", "Len", "==", "<NUM_LIT>", ")", "ExtOpc", "=", "Signed", "?", "Hexagon", "::", "A2_sxtb", ":", "Hexagon", "::", "A2_zxtb", ";", "else", "if", "(", "Len", "==", "<NUM_LIT>", ")", "ExtOpc", "=", "Signed", "?", "Hexagon", "::", "A2_sxth", ":", "Hexagon", "::", "A2_zxth", ";", "else", "if", "(", "Len", "<", "<NUM_LIT>", "&&", "!", "Signed", ")", "ExtOpc", "=", "Hexagon", "::", "A2_andir", ";", "}", "if", "(", "ExtOpc", "==", "<NUM_LIT>", ")", "{", "ExtOpc", "=", "Signed", "?", "(", "RW", "==", "<NUM_LIT>", "?", "Hexagon", "::", "S4_extract", ":", "Hexagon", "::", "S4_extractp", ")", ":", "(", "RW", "==", "<NUM_LIT>", "?", "Hexagon", "::", "S2_extractu", ":", "Hexagon", "::", "S2_extractup", ")", ";", "}", "unsigned", "SR", "=", "<NUM_LIT>", ";", "if", "(", "RW", "!=", "SW", "&&", "RW", "*", "<NUM_LIT>", "!=", "SW", ")", "continue", ";", "if", "(", "RW", "!=", "SW", ")", "SR", "=", "(", "Off", "/", "RW", "==", "<NUM_LIT>", ")", "?", "Hexagon", "::", "isub_lo", ":", "Hexagon", "::", "isub_hi", ";", "Off", "=", "Off", "%", "RW", ";", "if", "(", "!", "validateReg", "(", "{", "R", ",", "SR", "}", ",", "ExtOpc", ",", "<NUM_LIT>", ")", ")", "continue", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ExtOpc", ")", "{", "const", "MachineOperand", "&", "SrcOp", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "SrcOp", ".", "getReg", "(", ")", "==", "R", ")", "continue", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "unsigned", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "FRC", ")", ";", "auto", "At", "=", "MI", "->", "isPHI", "(", ")", "?", "B", ".", "getFirstNonPHI", "(", ")", ":", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "ExtOpc", ")", ",", "NewR", ")", ".", "addReg", "(", "R", ",", "<NUM_LIT>", ",", "SR", ")", ";", "switch", "(", "ExtOpc", ")", "{", "case", "Hexagon", "::", "A2_sxtb", ":", "case", "Hexagon", "::", "A2_zxtb", ":", "case", "Hexagon", "::", "A2_sxth", ":", "case", "Hexagon", "::", "A2_zxth", ":", "break", ";", "case", "Hexagon", "::", "A2_andir", ":", "MIB", ".", "addImm", "(", "(", "<NUM_LIT>", "u", "<<", "Len", ")", "-", "<NUM_LIT>", ")", ";", "break", ";", "case", "Hexagon", "::", "S4_extract", ":", "case", "Hexagon", "::", "S2_extractu", ":", "case", "Hexagon", "::", "S4_extractp", ":", "case", "Hexagon", "::", "S2_extractup", ":", "MIB", ".", "addImm", "(", "Len", ")", ".", "addImm", "(", "Off", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected opcode", "<STR_LIT>", ")", ";", "}", "HBS", "::", "replaceReg", "(", "RD", ".", "Reg", ",", "NewR", ",", "MRI", ")", ";", "BT", ".", "put", "(", "BitTracker", "::", "RegisterRef", "(" ]

[ "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "vsli_n_s32", "(", "int32x2_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "int32x2_t", ")", "_", "_", "builtin_aarch64_ssli_nv2si", "(", "_", "_", "a", "," ]

[ "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld4_lanev8qi", "(", "(", "const", "_", "_", "builtin_neon_qi", "*", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_", "_", "o", ",", "_", "_", "c", ")", ";" ]

[ "union", "{", "poly8x8x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "union", "{", "poly8x8x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";", "}", "_", "_", "rv", ";" ]

[ "(", "TYPE_MODE", "(", "type", ")", ")", "==", "MODE_VECTOR_BOOL", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

[ "static", "HOST_WIDE_INT", "aarch64_simd_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "GET_MODE_CLASS" ]

[ "let", "addrMode", "=", "BaseLongOffset", ";" ]

[ "def", "L4_loadalignh_ur", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Ryy32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Ryy32in", ",", "IntRegs", ":", "$", "Rt32", ",", "u2_0Imm", ":", "$", "Ii", ",", "u32_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_a5d4aeec", ",", "TypeLD", ">", ",", "Enc_04c959", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "GPR32", ",", "movimm32_shift", ",", "asm", ">", "{" ]

[ "def", "Wi", ":", "BaseMoveImmediate", "<", "opc", "," ]

[ "S", "->", "isNonTemporal", "(", ")", ",", "S", "->", "getAlignment", "(", ")", ")", ";" ]

[ "if", "(", "IsMinSize", ")", "return", "SDValue", "(", ")", ";", "SDValue", "StVal", "=", "S", "->", "getValue", "(", ")", ";", "EVT", "VT", "=", "StVal", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getVectorNumElements", "(", ")", "<", "<NUM_LIT>", "||", "VT", "==", "MVT", "::", "v2i64", ")", "return", "SDValue", "(", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "!=", "<NUM_LIT>", "||", "S", "->", "getAlignment", "(", ")", ">=", "<NUM_LIT>", "||", "S", "->", "getAlignment", "(", ")", "<=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ReplacedSplat", "=", "replaceSplatVectorStore", "(", "DAG", ",", "S", ")", ";", "if", "(", "ReplacedSplat", "!=", "SDValue", "(", ")", ")", "return", "ReplacedSplat", ";", "SDLoc", "DL", "(", "S", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ";", "EVT", "HalfVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ".", "getVectorElementType", "(", ")", ",", "NumElts", ")", ";", "SDValue", "SubVector0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "HalfVT", ",", "StVal", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "SDValue", "SubVector1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "HalfVT", ",", "StVal", ",", "DAG", ".", "getConstant", "(", "NumElts", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "SDValue", "BasePtr", "=", "S", "->", "getBasePtr", "(", ")", ";", "SDValue", "NewST1", "=", "DAG", ".", "getStore", "(", "S", "->", "getChain", "(", ")", ",", "DL", ",", "SubVector0", ",", "BasePtr", ",", "S", "->", "getPointerInfo", "(", ")", ",", "S", "->", "isVolatile", "(", ")", ",", "S", "->", "isNonTemporal", "(", ")", ",", "S", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "OffsetPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i64", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "return", "DAG", ".", "getStore", "(", "NewST1", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "SubVector1", ",", "OffsetPtr", ",", "S", "->", "getPointerInfo", "(", ")", ",", "S", "->", "isVolatile", "(", ")", "," ]

[ "(", "TM", ")", ".", "getSubtargetImpl", "(", ")", ";" ]

[ "Subtarget", "=", "static_cast", "<", "M68kTargetMachine", "&", ">" ]

[ "emit_insn", "(", "gen_and", "<", "GPR", ":", "mode", ">", "<NUM_LIT>", "(", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "[", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "GPR", "(", "match_operand", ":", "SHORT", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_MIPS16", "&", "&", "!", "GENERATE_MIPS16E", "&", "&", "!", "memory_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<", "SHORT", ":", "MODE", ">", "mode", ")", ")", "{" ]

[ "<FIXS>", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AssertSext", "||", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND_INREG", ")", "&&", "dyn_cast", "VTSDNode", ">", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getVT", "(", ")", ".", "bitsLE", "(", "MVT", "::", "i32", ")", ")", "<FIXE>", "<FIXS>", "EVT", "OpVT", "=", "Op0", ".", "getValueType", "(", ")", ";", "EVT", "RetVT", "=", "Op", ".", "getValueType", "(", ")", ";", "RTLIB", "::", "Libcall", "LC", "=", "RTLIB", "::", "getSINTTOFP", "(", "OpVT", ",", "RetVT", ")", ";", "MakeLibCallOptions", "CallOptions", ";", "CallOptions", ".", "setTypeListBeforeSoften", "(", "OpVT", ",", "RetVT", ",", "true", ")", ";", "SDValue", "Chain", "=", "SDValue", "(", ")", ";", "SDValue", "Result", ";", "std", "::", "tie", "(", "Result", ",", "Chain", ")", "=", "makeLibCall", "(", "DAG", ",", "LC", ",", "Op", ".", "getValueType", "(", ")", ",", "Op0", ",", "CallOptions", ",", "DL", ",", "Chain", ")", ";", "return", "Result", ";", "<FIXE>" ]

[ "SDValue", "LoongArchTargetLowering", "::", "lowerUINT_TO_FP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "<BUGS>", "auto", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "SDValue", "Tmp1", ",", "Tmp2", ";", "SDValue", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op1", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AssertZext", "||", "Op1", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AssertSext", ")", "<BUGE>", "return", "Op", ";", "<BUGS>", "SDValue", "Trunc", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "UINT_TO_FP", ",", "DL", ",", "MVT", "::", "f64", ",", "Trunc", ")", ";", "SDNode", "*", "N", "=", "Res", ".", "getNode", "(", ")", ";", "TLI", ".", "expandUINT_TO_FP", "(", "N", ",", "Tmp1", ",", "Tmp2", ",", "DAG", ")", ";", "return", "Tmp1", ";", "<BUGE>", "}", "SDValue", "LoongArchTargetLowering", "::", "lowerBITCAST", "(", "SDValue", "Op", "," ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "vec_concat", ":", "V8DF", "(", "match_operand", ":", "V4DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

[ "regtype", ":", "$", "Rm", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", ",", "ReadI", "]", ">", ";" ]

[ "class", "BaseAddSubRegPseudo", "<", "RegisterClass", "regtype", ",", "SDPatternOperator", "OpNode", ">", ":", "Pseudo", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ")", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "OpNode", "regtype", ":", "$", "Rn", "," ]

[ "}" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC1", ",", "SA1", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "<STR_LIT>", ">", "{", "<FIXE>" ]

[ ":", "DS_Pseudo", "opName", ",", "(", "outs", "rc", ":", "$", "vdst", ")", ",", "(", "ins", "VGPR_32", ":", "$", "addr", ",", "src", ":", "$", "data0", ",", "src", ":", "$", "data1", ",", "offset", ":", "$", "offset", ",", "gds", ":", "$", "gds", ")", ",", "<BUGS>", "<STR_LIT>", ">", "{", "<BUGE>", "let", "hasPostISelHook", "=", "<NUM_LIT>", ";", "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "I3", ";" ]

[ "class", "InstVRIh", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstSystemZ", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "I2", ";" ]

[ ":" ]

[ "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performCMovFPCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD" ]

[ "(", "I", ")", "->", "isAtomic", "(", ")", ")", "return", "false", ";" ]

[ "MVT", "VT", ";", "if", "(", "!", "isLoadStoreTypeLegal", "(", "I", "->", "getType", "(", ")", ",", "VT", ")", "||", "cast", "<", "LoadInst", ">" ]

[ "StringRef", "X86TargetLowering", "::", "getStackProbeSymbolName", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasInlineStackProbe", "(", "MF", ")", ")", "return", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "probe-stack", "<STR_LIT>", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "<STR_LIT>", "probe-stack", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isOSWindows", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "no-stack-arg-probe", "<STR_LIT>", ")", ")", "return", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "<STR_LIT>", "___chkstk_ms", "<STR_LIT>", ":", "<STR_LIT>", "__chkstk", "<STR_LIT>", ";", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "<STR_LIT>", "_alloca", "<STR_LIT>", ":", "<STR_LIT>", "_chkstk", "<STR_LIT>", ";", "}" ]

[ "Returns", "the", "name", "of", "the", "symbol", "used", "to", "emit", "stack", "probes", "or", "the", "empty", "string", "if", "not", "applicable", "." ]

[ "<", "B30", ">", ";" ]

[ "def", "S30", ":", "ARM64Reg", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "H30", "]", ">", ",", "DwarfRegAlias" ]

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "tree", "mem_type", "=", "build_aligned_type", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "<NUM_LIT>", "]", ")", ",", "align", ")", ";" ]

[ "case", "S390_OVERLOADED_BUILTIN_s390_vec_xl", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xld2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xlw4", ":", "{", "unsigned", "align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "<NUM_LIT>", "]", ")", ")", ")", ";", "tree", "mem_type", "=", "build_aligned_type", "(", "return_type", ",", "align", ")", ";", "return", "build2", "(", "MEM_REF", ",", "mem_type", ",", "fold_build_pointer_plus", "(", "(", "*", "arglist", ")", "[", "<NUM_LIT>", "]", ",", "(", "*", "arglist", ")", "[", "<NUM_LIT>", "]", ")", ",", "build_int_cst", "(", "ptr_type_node", ",", "<NUM_LIT>", ")", ")", ";", "}", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xst", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstd2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstw4", ":", "{", "unsigned", "align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "<NUM_LIT>", "]", ")", ")", ")", ";" ]

[ ",", "fast", ")", ";" ]

[ "return", "new", "IA64AsmPrinter", "(", "o", ",", "tm", ",", "tm", ".", "getTargetAsmInfo", "(", ")" ]

[ "hexagon-ext", "<STR_LIT>" ]

[ "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "HexagonInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "HexagonII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "HMOTF_ConstExtended", ",", "<STR_LIT>" ]

[ "C", ":" ]

[ "SDValue", "AAPTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported calling convention", "<STR_LIT>", ")", ";", "case", "CallingConv", "::" ]

[ "<FIXS>", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_SSE_MATH", ")", "*", "total", "=", "ix86_cost", "->", "fdiv", ";", "else", "if", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", ")", "*", "total", "=", "ix86_cost", "->", "fdiv", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "<FIXE>", "<FIXS>", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "<FIXE>" ]

[ "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "<BUGS>", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "<BUGE>", "*", "total", "=", "ix86_cost", "->", "fdiv", ";", "else", "*", "total", "=", "ix86_cost", "->", "divide", "[", "MODE_INDEX", "(", "mode", ")", "]", ";", "return", "false", ";", "case", "PLUS", ":", "<BUGS>", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "*", "total", "=", "ix86_cost", "->", "fadd", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "<BUGE>", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "GET_MODE_BITSIZE", "(", "Pmode", ")", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS" ]

[ ")", ")", "]", ")", "]" ]

[ "(", "define_split", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ne", ":", "SI", "(", "gt", ":", "CC", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "<NUM_LIT>" ]

[ "static", "void", "restore_saved_cr", "(", "rtx", "reg", ",", "bool", "using_mfcr_multiple", ",", "bool", "exit_func", ")", "{", "int", "count", "=", "<NUM_LIT>", ";", "int", "i", ";", "if", "(", "using_mfcr_multiple", ")", "{", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "count", "++", ";", "gcc_assert", "(", "count", ")", ";", "}", "if", "(", "using_mfcr_multiple", "&&", "count", ">", "<NUM_LIT>", ")", "{", "rtx_insn", "*", "insn", ";", "rtvec", "p", ";", "int", "ndx", ";", "p", "=", "rtvec_alloc", "(", "count", ")", ";", "ndx", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtvec", "r", "=", "rtvec_alloc", "(", "<NUM_LIT>", ")", ";", "RTVEC_ELT", "(", "r", ",", "<NUM_LIT>", ")", "=", "reg", ";", "RTVEC_ELT", "(", "r", ",", "<NUM_LIT>", ")", "=", "GEN_INT", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "i", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "ndx", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "gen_rtx_UNSPEC", "(", "CCmode", ",", "r", ",", "UNSPEC_MOVESI_TO_CR", ")", ")", ";", "ndx", "++", ";", "}", "insn", "=", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "gcc_assert", "(", "ndx", "==", "count", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}", "else", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtx", "insn", "=", "emit_insn", "(", "gen_movsi_to_cr_one", "(", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "reg", ")", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "!=", "ABI_ELFv2", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "flag_shrink_wrap", ")", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "cr", "=", "gen_rtx_REG", "(", "SImode", ",", "CR2_REGNO", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "cr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}" ]

[ "Reload", "CR", "from", "REG", "." ]

[ ",", "dl", ",", "MVT", "::", "i32", ",", "JTI", ")", ";" ]

[ "if", "(", "IsPIC", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "JTI", "}", ";", "HiPart", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ")", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "}", "else", "HiPart", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "JTI", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>" ]

[ ")", "]", ")" ]

[ "[", "(", "unspec_volatile", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_DSSALL", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]