Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "const", "{" ]

[ "bool", "isMemRI", "(", ")" ]

[ ")", ";" ]

[ "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "unsigned", "RegIndex", ",", "Register", "Addr", ",", "uint64_t", "MemSize", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "unsigned", "MaxSize", "=", "MemSize", "*", "<NUM_LIT>", ";", "if", "(", "!", "Arg", ".", "IsFixed", ")", "MaxSize", "=", "<NUM_LIT>", ";", "Register", "ValVReg", "=", "Arg", ".", "Regs", "[", "RegIndex", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", ")", "{", "MVT", "LocVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "MVT", "ValVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i8", "||", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i16", ")", "{", "std", "::", "swap", "(", "ValVT", ",", "LocVT", ")", ";", "MemSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "}", "ValVReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ",", "MaxSize" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fma", ":", "DF", "(", "neg", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "<FIXS>", "*", "cost", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ",", "PLUS", ",", "<NUM_LIT>", ",", "speed_p", ")", ";", "<FIXE>" ]

[ "*", "cost", "=", "COSTS_N_INSNS", "(", "insns", ")", ";", "if", "(", "speed_p", ")", "*", "cost", "+=", "insns", "*", "extra_cost", "->", "alu", ".", "arith", ";", "<BUGS>", "*", "cost", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "PLUS", ",", "<NUM_LIT>", ",", "speed_p", ")", ";", "<BUGE>", "return", "true", ";", "}", "else", "if", "(", "speed_p", ")" ]

[ "}" ]

[ "int", "i", ";", "inner", "=", "GET_MODE", "(", "dest", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "GET_MODE_SIZE", "(", "inner", ")", ";", "i", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "emit_move_insn", "(", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "inner", ",", "i", ")", ",", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "inner", ",", "i", ")", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "vec_select", ":", "V8QI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]" ]

[ ",", "DwarfRegAlias", "<", "B2", ">", ";" ]

[ "def", "H2", ":", "AArch64Reg", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "B2", "]", ">" ]

[ "outval", ")", ")", ";" ]

[ "rtx", "ref", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "outval", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "base", ",", "scratch", ";", "HOST_WIDE_INT", "offset", "=", "<NUM_LIT>", ";", "if", "(", "SUBREG_P", "(", "ref", ")", ")", "{", "offset", "=", "SUBREG_BYTE", "(", "ref", ")", ";", "ref", "=", "SUBREG_REG", "(", "ref", ")", ";", "}", "if", "(", "REG_P", "(", "ref", ")", ")", "{", "if", "(", "reg_equiv_mem", "(", "REGNO", "(", "ref", ")", ")", ")", "{", "ref", "=", "reg_equiv_mem", "(", "REGNO", "(", "ref", ")", ")", ";", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "base", "=", "reg_equiv_address", "(", "REGNO", "(", "ref", ")", ")", ";", "if", "(", "base", "==", "NULL", ")", "{", "gcc_assert", "(", "REG_P", "(", "outval", ")", "||", "SUBREG_P", "(", "outval", ")", ")", ";", "if", "(", "REG_P", "(", "outval", ")", ")", "{", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "ref", ",", "<NUM_LIT>", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "outval", ",", "<NUM_LIT>", ")", ")", ")", ";", "}", "else", "{", "if", "(", "GET_MODE", "(", "SUBREG_REG", "(", "outval", ")", ")", "==", "SImode", ")", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "ref", ",", "<NUM_LIT>", ")", ",", "SUBREG_REG", "(", "outval", ")", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "}", "else", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "<NUM_LIT>", ")", ")", ";", "scratch", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "MINUS", "||", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ")", ")", ")", "{", "rtx", "base_plus", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "<NUM_LIT>", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "base_plus", ",", "outval", ")", ")", "{", "if", "(", "!", "reg_overlap_mentioned_p", "(", "scratch", ",", "outval", ")", ")", "std", "::", "swap", "(", "scratch", ",", "base_plus", ")", ";", "else", "{", "rtx", "scratch_hi", "=", "gen_rtx_REG", "(", "HImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_movhi", "(", "scratch_hi", "," ]

[ "DL", ",", "VTs", ",", "Ops", ")", ";" ]

[ "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "NumOperands", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "SDValue", "(", "Op", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ";", "default", ":", "default_case", ":", "break", ";", "}", "if", "(", "NeedTruncation", ")", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDValue", "WideVal", "=", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "WideVT", "=", "WideVal", ".", "getValueType", "(", ")", ";", "unsigned", "ConvertedOp", "=", "<NUM_LIT>", ";", "switch", "(", "WideVal", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "ConvertedOp", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SUB", ":", "ConvertedOp", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "AND", ":", "ConvertedOp", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "OR", ":", "ConvertedOp", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "XOR", ":", "ConvertedOp", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "if", "(", "ConvertedOp", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "TLI", ".", "isOperationLegal", "(", "WideVal", ".", "getOpcode", "(", ")", ",", "WideVT", ")", ")", "{", "SDValue", "V0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "WideVal", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "V1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "WideVal", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ConvertedOp", ",", "DL", ",", "VT", ",", "V0", ",", "V1", ")", ";", "}", "}", "}", "if", "(", "Opcode", "==", "<NUM_LIT>", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i8", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ")", ",", "Op", ")", ";", "}", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getValueType", "(", ")", ",", "MVT", "::", "i8", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "(", "Op", "->", "op_begin", "(", ")", ",", "Op", "->", "op_begin", "(", ")", "+", "NumOperands", ")", ";", "SDValue", "New", "=", "DAG", ".", "getNode", "(", "Opcode", "," ]

[ ")", ";" ]

[ "return", "new", "X86PreTileConfig", "(" ]

[ "<STR_LIT>" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "BI", "CARRY_REG", ")", ")", "]" ]

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

[ "class", "InstRSLb", "<", "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>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "BDL2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "BDL2", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ "<FIXS>", "while", "(", "(", "ArgOffset", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "ArgOffset", "+=", "PtrByteSize", ";", "if", "(", "GPR_idx", "!=", "Num_GPR_Regs", ")", "GPR_idx", "++", ";", "}", "<FIXE>", "<FIXS>", "+", "VR_idx", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v2i64", ":", "<BUGS>", "<BUGE>", "if", "(", "VR_idx", "!=", "Num_VR_Regs", ")", "{", "unsigned", "VReg", "=", "(", "ObjectVT", "==", "MVT", "::", "v2f64", "||", "ObjectVT", "==", "MVT", "::", "v2i64", ")", "?", "MF", ".", "addLiveIn", "(", "VSRH", "[", "VR_idx", "]", ",", "&", "PPC", "::", "VSHRCRegClass", ")", ":", "MF", ".", "addLiveIn", "(", "VR", "[", "VR_idx", "]", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "ArgVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "ObjectVT", ")", ";", "<BUGS>", "if", "(", "isVarArg", ")", "{", "while", "(", "(", "ArgOffset", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "ArgOffset", "+=", "PtrByteSize", ";", "if", "(", "GPR_idx", "!=", "Num_GPR_Regs", ")", "GPR_idx", "++", ";", "}", "ArgOffset", "+=", "<NUM_LIT>", ";", "GPR_idx", "=", "std", "::", "min", "(", "GPR_idx", "+", "<NUM_LIT>", ",", "Num_GPR_Regs", ")", ";", "}", "<BUGE>", "}", "else", "{", "<BUGS>", "ArgOffset", "=", "(", "(", "ArgOffset", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "<BUGE>", "CurArgOffset", "=", "ArgOffset", ";", "<BUGS>", "ArgOffset", "+=", "<NUM_LIT>", ";", "<BUGE>", "needsLoad", "=", "true", ";", "}", "break", ";", "}" ]

[ "<FIXS>", "#", "include", "<STR_LIT>", "c-family/c-common.h", "<STR_LIT>", "<FIXE>", "<FIXS>", "#", "include", "<STR_LIT>", "c-family/c-pragma.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "tree.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "tm_p.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "flags.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "c-common.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "ggc.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "target.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "target-def.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "cpplib.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "c-pragma.h", "<STR_LIT>", "<BUGE>", "static", "bool", "ix86_pragma_target_parse", "(", "tree", ",", "tree", ")", ";", "static", "void", "ix86_target_macros_internal" ]

[ ")", "{", "return", "IsSubReg", "(", "RegA", ",", "Reg", ")", ";", "}", ")", ")", "return", "true", ";" ]

[ "return", "TRI", ".", "isSuperOrSubRegisterEq", "(", "RegA", ",", "RegB", ")", ";", "}", ";", "if", "(", "!", "ST", ".", "is64Bit", "(", ")", ")", "return", "llvm", "::", "any_of", "(", "SmallVector", "<", "MCRegister", ">", "{", "X86", "::", "EAX", ",", "X86", "::", "ECX", ",", "X86", "::", "EDX", "}", ",", "[", "&", "]", "(", "MCRegister", "&", "RegA", ")", "{", "return", "IsSubReg", "(", "RegA", ",", "Reg", ")", ";", "}", ")", "||", "(", "ST", ".", "hasMMX", "(", ")", "&&", "X86", "::", "VR64RegClass", ".", "contains", "(", "Reg", ")", ")", ";", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "X86_64_SysV", "&&", "IsSubReg", "(", "X86", "::", "RAX", ",", "Reg", ")", ")", "return", "true", ";", "if", "(", "llvm", "::", "any_of", "(", "SmallVector", "<", "MCRegister", ">", "{", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "R8", ",", "X86", "::", "R9", "}", ",", "[", "&", "]", "(", "MCRegister", "&", "RegA", ")", "{", "return", "IsSubReg", "(", "RegA", ",", "Reg", ")", ";", "}", ")", ")", "return", "true", ";", "if", "(", "CC", "!=", "CallingConv", "::", "Win64", "&&", "llvm", "::", "any_of", "(", "SmallVector", "<", "MCRegister", ">", "{", "X86", "::", "RDI", ",", "X86", "::", "RSI", "}", ",", "[", "&", "]", "(", "MCRegister", "&", "RegA", ")", "{", "return", "IsSubReg", "(", "RegA", ",", "Reg", ")", ";", "}", ")", ")", "return", "true", ";", "if", "(", "ST", ".", "hasSSE1", "(", ")", "&&", "llvm", "::", "any_of", "(", "SmallVector", "<", "MCRegister", ">", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ",", "[", "&", "]", "(", "MCRegister", "&", "RegA" ]

[ "_", "mm512_undefined_epi32", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pmovzxdq512_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "X", ",", "(", "_", "_", "v8di", ")" ]

[ "}" ]

[ "}", "return", "StringSwitch", "<", "MipsABIInfo", ">", "(", "CPU", ")", ".", "Case", "(", "<STR_LIT>", "mips1", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips2", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips32", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips32r2", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips32r3", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips32r5", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips32r6", "<STR_LIT>", ",", "MipsABIInfo", "::", "O32", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips3", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips4", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips5", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips64", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips64r2", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips64r3", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips64r5", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "mips64r6", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "octeon", "<STR_LIT>", ",", "MipsABIInfo", "::", "N64", "(", ")", ")", ".", "Default", "(", "MipsABIInfo", "::", "Unknown", "(", ")", ")", ";" ]

[ "<FIXS>", "!", "IsShiftedMask", "(", "CN", "->", "getZExtValue", "(", ")", ",", "SMPos", ",", "SMSize", ")", ")", "<FIXE>" ]

[ "uint64_t", "SMPos", ",", "SMSize", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "ConstantSDNode", ">", "(", "Mask", ")", ")", "||", "<BUGS>", "!", "IsShiftedMask", "(", "CN", "->", "getZExtValue", "(", ")", ",", "<NUM_LIT>", ",", "SMPos", ",", "SMSize", ")", ")", "<BUGE>", "return", "SDValue", "(", ")", ";" ]

[ "|", "|", "satisfies_constraint_Iu15", "(", "op", ")" ]

[ "|", "|", "satisfies_constraint_Izeh", "(", "op", ")", "|", "|", "satisfies_constraint_Ixls", "(", "op", ")", "|", "|", "satisfies_constraint_Ix11", "(", "op", ")", "|", "|", "satisfies_constraint_Ibms", "(", "op", ")", "|", "|", "satisfies_constraint_Ifex", "(", "op", ")" ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

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

[ "return", "<NUM_LIT>", ";", "case", "X86", "::", "GR32RegClassID", ":", "return", "<NUM_LIT>", "-", "FPDiff", ";", "case", "X86", "::", "GR64RegClassID", ":", "return", "<NUM_LIT>", "-", "FPDiff", ";", "case", "X86", "::", "VR128RegClassID", ":", "return", "Subtarget", ".", "is64Bit", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "case", "X86", "::", "VR64RegClassID", ":" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "ALL8", "[", "DI", "DQ", "UDQ", "DA", "UDA", "TA", "UTA" ]

[ "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";" ]

[ "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L" ]

[ ",", "CompareSSIOffset", ")", ";" ]

[ "SpillList", ".", "push_back", "(", "StackSlotInfo", "(", "EHSlot", "[", "<NUM_LIT>", "]", ",", "MFI", "->", "getObjectOffset", "(", "EHSlot", "[", "<NUM_LIT>", "]", ")", ",", "TL", "->", "getExceptionSelectorRegister", "(", "PersonalityFn", ")", ")", ")", ";", "std", "::", "sort", "(", "SpillList", ".", "begin", "(", ")", ",", "SpillList", ".", "end", "(", ")" ]

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

[ "class", "EI_MMR6_ENC", ":", "EIDI_MMR6_ENC", "<" ]

[ "<<", "<STR_LIT>", " w/feature ", "<STR_LIT>", "<<", "Other", ".", "Features", "<<", "'", "\\n", "'", ")", ";" ]

[ "static", "void", "collectDependencies", "(", "const", "SwitchInfo", "&", "E", ",", "std", "::", "vector", "<", "DependencyRecord", ">", "&", "V", ")", "{", "for", "(", "auto", "&", "Other", ":", "AllSwitches", ")", "for", "(", "auto", "&", "D", ":", "E", ".", "Dependencies", ")", "if", "(", "Other", ".", "Name", ".", "equals_lower", "(", "D", ".", "Switch", ")", ")", "{", "if", "(", "(", "Other", ".", "OpType", "&", "E", ".", "OpType", ")", "!=", "<NUM_LIT>", "&&", "E", ".", "fitsOtherFeatures", "(", "Other", ")", "&&", "Other", ".", "Instructions", ".", "end", "(", ")", "!=", "std", "::", "find_first_of", "(", "Other", ".", "Instructions", ".", "begin", "(", ")", ",", "Other", ".", "Instructions", ".", "end", "(", ")", ",", "E", ".", "Instructions", ".", "begin", "(", ")", ",", "E", ".", "Instructions", ".", "end", "(", ")", ",", "[", "=", "]", "(", "const", "MnemonicKey", "&", "R", ",", "const", "MnemonicKey", "&", "L", ")", "->", "bool", "{", "return", "(", "R", ".", "Slot", "&", "L", ".", "Slot", ")", "!=", "<NUM_LIT>", "&&", "R", ".", "Mnemonic", "==", "L", ".", "Mnemonic", ";", "}", ")", ")", "{", "V", ".", "push_back", "(", "DependencyRecord", "{", "&", "Other", ",", "D", ".", "Value", "}", ")", ";", "DISASM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Added switch dependency: ", "<STR_LIT>", "<<", "E", ".", "Name", "<<", "<STR_LIT>", " => ", "<STR_LIT>", "<<", "D", ".", "first", "<<", "<STR_LIT>", " == ", "<STR_LIT>", "<<", "D", ".", "second" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " with instructions:\\n ", "<STR_LIT>", ")", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Remove load instruction:\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "LoadI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LoadI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "StRtIsKill", ")", "getLdStRegOp", "(", "StoreI", ")", ".", "setIsKill", "(", "false", ")", ";", "return", "NextI", ";", "}", "BitExtMI", "=", "BuildMI", "(", "*", "LoadI", "->", "getParent", "(", ")", ",", "LoadI", ",", "LoadI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "LdRt", ")", ".", "addReg", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "StRt", ",", "getKillRegState", "(", "StRtIsKill", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "if", "(", "!", "Subtarget", "->", "isLittleEndian", "(", ")", ")", "return", "NextI", ";", "bool", "IsUnscaled", "=", "TII", "->", "isUnscaledLdSt", "(", "LoadI", ")", ";", "assert", "(", "IsUnscaled", "==", "TII", "->", "isUnscaledLdSt", "(", "StoreI", ")", "&&", "<STR_LIT>", "Unsupported ld/st match", "<STR_LIT>", ")", ";", "assert", "(", "LoadSize", "<=", "StoreSize", "&&", "<STR_LIT>", "Invalid load size", "<STR_LIT>", ")", ";", "int", "UnscaledLdOffset", "=", "IsUnscaled", "?", "getLdStOffsetOp", "(", "LoadI", ")", ".", "getImm", "(", ")", ":", "getLdStOffsetOp", "(", "LoadI", ")", ".", "getImm", "(", ")", "*", "LoadSize", ";", "int", "UnscaledStOffset", "=", "IsUnscaled", "?", "getLdStOffsetOp", "(", "StoreI", ")", ".", "getImm", "(", ")", ":", "getLdStOffsetOp", "(", "StoreI", ")", ".", "getImm", "(", ")", "*", "StoreSize", ";", "int", "Width", "=", "LoadSize", "*", "<NUM_LIT>", ";", "int", "Immr", "=", "<NUM_LIT>", "*", "(", "UnscaledLdOffset", "-", "UnscaledStOffset", ")", ";", "int", "Imms", "=", "Immr", "+", "Width", "-", "<NUM_LIT>", ";", "unsigned", "DestReg", "=", "IsStoreXReg", "?", "TRI", "->", "getMatchingSuperReg", "(", "LdRt", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ":", "LdRt", ";", "assert", "(", "(", "UnscaledLdOffset", ">=", "UnscaledStOffset", "&&", "(", "UnscaledLdOffset", "+", "LoadSize", ")", "<=", "UnscaledStOffset", "+", "StoreSize", ")", "&&", "<STR_LIT>", "Invalid offset", "<STR_LIT>", ")", ";", "Immr", "=", "<NUM_LIT>", "*", "(", "UnscaledLdOffset", "-", "UnscaledStOffset", ")", ";", "Imms", "=", "Immr", "+", "Width", "-", "<NUM_LIT>", ";", "if", "(", "UnscaledLdOffset", "==", "UnscaledStOffset", ")", "{", "uint32_t", "AndMaskEncoded", "=", "(", "(", "IsStoreXReg", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Immr", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Imms", ")", "<<", "<NUM_LIT>", ")", ";", "BitExtMI", "=", "BuildMI", "(", "*", "LoadI", "->", "getParent", "(", ")", ",", "LoadI", ",", "LoadI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "StRt", ",", "getKillRegState", "(", "StRtIsKill", ")", ")", ".", "addImm", "(", "AndMaskEncoded", ")", ";", "}", "else", "{", "BitExtMI", "=", "BuildMI", "(", "*", "LoadI", "->", "getParent", "(", ")", ",", "LoadI", ",", "LoadI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "StRt", ",", "getKillRegState", "(", "StRtIsKill", ")", ")", ".", "addImm", "(", "Immr", ")", ".", "addImm", "(", "Imms", ")", ";", "}", "}", "(", "void", ")", "BitExtMI", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Promoting load by replacing :\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "StoreI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "DEBUG", "(", "LoadI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "for", "(", "MachineOperand", "&", "MO", ":", "StoreI", "->", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isKill", "(", ")", "&&", "TRI", "->", "regsOverlap", "(", "MO", ".", "getReg", "(", ")", ",", "StRt", ")", ")", "MO", ".", "setIsKill", "(", "false", ")", ";", "}" ]

[ ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "i64", "FPR64", ":", "$", "Rn", ")", ",", "(", "i32", "vecshiftL64", ":", "$", "imm", ")", ")", ")", "]", ">", "{" ]

[ "def", "d", ":", "BaseSIMDScalarShift", "<", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", "}", ",", "FPR64", ",", "FPR64", ",", "vecshiftL64", ",", "asm", ",", "[", "(", "set", "(", "i64", "FPR64" ]

[ ";" ]

[ "class", "AI_exta_rrot_np", "<", "bits", "<", "<NUM_LIT>", ">", "opcod", ",", "string", "opc", ">", ":", "AExtI", "<", "opcod", ",", "(", "outs", "GPRnopc", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "GPRnopc", ":", "$", "Rm", ",", "rot_imm", ":", "$", "rot", ")", ",", "IIC_iEXTAr", ",", "opc", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Requires", "<", "[", "IsARM", ",", "HasV6", "]", ">", ",", "Sched", "<", "[", "WriteALUsr", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "rot" ]

[ "Index", ")", ";" ]

[ "if", "(", "isa", "<", "StructType", ">", "(", "CompType", ")", ")", "{", "assert", "(", "isa", "<", "ConstantInt", ">", "(", "*", "Offset", ")", "&&", "<STR_LIT>", "Variable offset used for field access", "<STR_LIT>", ")", ";", "unsigned", "PadOffset", "=", "<NUM_LIT>", ";", "unsigned", "ConstOffset", "=", "cast", "<", "ConstantInt", ">", "(", "*", "Offset", ")", "->", "getZExtValue", "(", ")", ";", "StructType", "*", "STy", "=", "cast", "<", "StructType", ">", "(", "CompType", ")", ";", "const", "StructLayout", "*", "SL", "=", "DL", ".", "getStructLayout", "(", "STy", ")", ";", "int", "i", "=", "GetStructElmIndexAtOffset", "(", "STy", ",", "ConstOffset", ",", "PadOffset", ")", ";", "Indices", ".", "push_back", "(", "ConstantInt", "::", "get", "(", "TargetIdxTy", ",", "i", ")", ")", ";", "unsigned", "ElmOffset", "=", "SL", "->", "getElementOffset", "(", "i", ")", ";", "Value", "*", "ElmOffsetVal", "=", "ConstantInt", "::", "get", "(", "TargetIdxTy", ",", "ElmOffset", ")", ";", "*", "Offset", "=", "IRB", ".", "CreateBinOp", "(", "Instruction", "::", "Sub", ",", "*", "Offset", ",", "ElmOffsetVal", ")", ";", "if", "(", "isa", "<", "CompositeType", ">", "(", "STy", "->", "getTypeAtIndex", "(", "i", ")", ")", ")", "GetIndicesForCompositeElemAccess", "(", "IRB", ",", "Indices", ",", "STy", "->", "getTypeAtIndex", "(", "i", ")", ",", "Offset", ")", ";", "}", "else", "if", "(", "isa", "<", "ArrayType", ">", "(", "CompType", ")", ")", "{", "Type", "*", "ElmTy", "=", "cast", "<", "ArrayType", ">", "(", "CompType", ")", "->", "getElementType", "(", ")", ";", "Value", "*", "ElmSz", "=", "ConstantInt", "::", "get", "(", "TargetIdxTy", ",", "DL", ".", "getTypeSizeInBits", "(", "ElmTy", ")", "/", "<NUM_LIT>", ")", ";", "Value", "*", "Index", "=", "IRB", ".", "CreateBinOp", "(", "Instruction", "::", "UDiv", ",", "*", "Offset", ",", "ElmSz", ")", ";", "Indices", ".", "push_back", "(", "Index", ")", ";", "*", "Offset", "=", "IRB", ".", "CreateBinOp", "(", "Instruction", "::", "URem", ",", "*", "Offset", ",", "ElmSz", ")", ";", "if", "(", "isa", "<", "CompositeType", ">", "(", "ElmTy", ")", ")", "GetIndicesForCompositeElemAccess", "(", "IRB", ",", "Indices", ",", "ElmTy", ",", "Offset", ")", ";", "}", "else", "{", "Value", "*", "CompTypeSz", "=", "ConstantInt", "::", "get", "(", "TargetIdxTy", ",", "DL", ".", "getTypeSizeInBits", "(", "CompType", ")", "/", "<NUM_LIT>", ")", ";", "Value", "*", "Index", "=", "IRB", ".", "CreateBinOp", "(", "Instruction", "::", "UDiv", ",", "*", "Offset", ",", "CompTypeSz", ")", ";", "Indices", ".", "push_back", "(" ]

[ "MBlazeTargetLowering", "::", "ConstraintType", "MBlazeTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "switch", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "{", "default", ":", "break", ";", "case", "'", "d", "'", ":", "case", "'", "y", "'", ":", "case", "'", "f", "'", ":", "return", "C_RegisterClass", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}" ]

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

[ "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_946df596", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{" ]

[ "def", "A2_vsubub", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

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

[ "let", "src1_neg", "=", "<NUM_LIT>", ";", "let", "src1_abs", "=", "<NUM_LIT>", ";", "let", "write", "=", "<NUM_LIT>", ";", "let", "omod", "=", "<NUM_LIT>", ";", "let", "clamp", "=", "<NUM_LIT>", ";", "let", "last", "=", "<NUM_LIT>", ";", "let", "bank_swizzle", "=", "<NUM_LIT>", ";", "let", "pred_sel", "=", "<NUM_LIT>", ";", "let", "update_exec_mask", "=", "<NUM_LIT>", ";", "let", "update_pred", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Word0", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Word1", ";" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "let", "Name", "=", "<STR_LIT>", "#", "width", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "width", "#", "<STR_LIT>", ";" ]

[ "op", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "let", "Inst", "=" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VIshort", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "rtx", "scratch", "=", "gen_reg_rtx", "(", "MODE", ">", "mode", ")", "if", "(", "BYTES_BIG_ENDIAN", ")" ]

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

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

[ "}" ]

[ "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "Mask", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "Lo", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v32i1", ",", "Lo", ")", ";", "Hi", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v32i1", ",", "Hi", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "dl", ",", "MVT", "::", "v64i1", ",", "Lo", ",", "Hi", ")", ";", "}", "else", "{", "MVT", "TruncVT", "=", "MVT", "::", "getIntegerVT", "(", "MaskVT", ".", "getSizeInBits", "(", ")", ")", ";", "return", "DAG", ".", "getBitcast", "(", "MaskVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "TruncVT", ",", "Mask", ")", ")", ";", "}", "}", "else", "{", "MVT", "BitcastVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "Mask", ".", "getSimpleValueType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "MaskVT", ",", "DAG", ".", "getBitcast", "(", "BitcastVT", ",", "Mask", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "}" ]

[ "unsigned", "Sub", "=", "(", "Opc", "==", "Hexagon", "::", "A4_combineir", ")", "?", "Hexagon", "::", "subreg_loreg", ":", "Hexagon", "::", "subreg_hireg", ";" ]

[ "assert", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "<NUM_LIT>", ")", ";", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "COPY", ":", "case", "Hexagon", "::", "A2_tfr", ":", "case", "Hexagon", "::", "A2_tfrp", ":", "{", "BitTracker", "::", "RegisterRef", "RS", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "HBS", "::", "isTransparentCopy", "(", "RD", ",", "RS", ",", "MRI", ")", ")", "break", ";", "if", "(", "RS", ".", "Sub", "!=", "<NUM_LIT>", ")", "Changed", "=", "HBS", "::", "replaceRegWithSub", "(", "RD", ".", "Reg", ",", "RS", ".", "Reg", ",", "RS", ".", "Sub", ",", "MRI", ")", ";", "else", "Changed", "=", "HBS", "::", "replaceReg", "(", "RD", ".", "Reg", ",", "RS", ".", "Reg", ",", "MRI", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "{", "BitTracker", "::", "RegisterRef", "SL", ",", "SH", ";", "if", "(", "HBS", "::", "parseRegSequence", "(", "MI", ",", "SL", ",", "SH", ")", ")", "{", "Changed", "=", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "Hexagon", "::", "subreg_loreg", ",", "SL", ".", "Reg", ",", "SL", ".", "Sub", ",", "MRI", ")", ";", "Changed", "|=", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "Hexagon", "::", "subreg_hireg", ",", "SH", ".", "Reg", ",", "SH", ".", "Sub", ",", "MRI", ")", ";", "}", "break", ";", "}", "case", "Hexagon", "::", "A2_combinew", ":", "{", "BitTracker", "::", "RegisterRef", "RH", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "RL", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Changed", "=", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "Hexagon", "::", "subreg_loreg", ",", "RL", ".", "Reg", ",", "RL", ".", "Sub", ",", "MRI", ")", ";", "Changed", "|=", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "Hexagon", "::", "subreg_hireg", ",", "RH", ".", "Reg", ",", "RH", ".", "Sub", ",", "MRI", ")", ";", "break", ";", "}", "case", "Hexagon", "::", "A4_combineir", ":", "case", "Hexagon", "::", "A4_combineri", ":", "{", "unsigned", "SrcX", "=", "(", "Opc", "==", "Hexagon", "::", "A4_combineir", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isAdd", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

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

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

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

[ "def", "XMM27", ":", "X86Reg", "<", "<STR_LIT>", ",", "<NUM_LIT>", ">", ",", "DwarfRegNum", "<", "[", "<NUM_LIT>", "," ]

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

[ "(", "plus", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "not", ":", "V2SI", "(", "and", ":", "V2SI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "emit_insn", "(", "gen_truncxfsf2_i387_noop_unspec", "(", "operands", "[", "<NUM_LIT>", "]", ",", "op1", ")", ")", "<FIXE>" ]

[ "emit_insn", "(", "gen_fpremxf4", "(", "op1", ",", "op2", ",", "op1", ",", "op2", ")", ")", "ix86_emit_fp_unordered_jump", "(", "label", ")", "<BUGS>", "emit_insn", "(", "gen_truncxfsf2", "(", "operands", "[", "<NUM_LIT>", "]", ",", "op1", ")", ")", "<BUGE>", "DONE", "}", ")" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "if_then_else", ":", "QI", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "QI", "(", "match_operator", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "if_then_else", ":", "QI", "(", "match_operator", ":", "CC_UNS", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "CC_UNS", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

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

[ "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", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Constraints" ]

[ "Range", ".", "intersect", "(", "getOffsetRange", "(", "Rd", ",", "*", "Op", ".", "getParent", "(", ")", ")", ")", ";" ]

[ "OffsetRange", "Range", ";", "for", "(", "const", "MachineOperand", "&", "Op", ":", "MRI", "->", "use_operands", "(", "Rd", ".", "Reg", ")", ")", "{", "if", "(", "Rd", "!=", "Register", "(", "Op", ")", ")", "return", "OffsetRange", "::", "zero", "(", ")", ";" ]

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

[ "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", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ "MachineBasicBlock", "*", "OR1KTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitSelect", "(", "MI", ",", "BB", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ",", "true", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "<NUM_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "emitAtomicCmpSwap", "(", "MI", ",", "BB", ")", ";", "}", "}" ]

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

[ "}" ]

[ "computeInsertionPoints", "(", "Val", ",", "InsertPtsPerFunc", ")", ";", "return", "insertDefinitions", "(", "Val", ",", "InsertPtsPerFunc", ")", ";" ]

[ "return", "_", "_", "builtin_neon_vfmsl_lane_lowv4sf", "(", "_", "_", "r", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "index", ")", ";" ]

[ "vfmlslq_laneq_low_f16", "(", "float32x4_t", "_", "_", "r", ",", "float16x8_t", "_", "_", "a", ",", "float16x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "index", ")", "{", "_", "_", "builtin_arm_lane_check", "(", "<NUM_LIT>", ",", "_", "_", "index", ")", ";" ]

[ "<", "am_indexed8", ">", ";" ]

[ "def", "gi_am_indexed8", ":", "GIComplexOperandMatcher", "<", "s64", ",", "<STR_LIT>", ">", ",", "GIComplexPatternEquiv" ]

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

[ "unsigned", "FP", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "RBP", ":", "X86", "::", "EBP", ";", "unsigned", "SP", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "MachineInstrBuilder", "MIB", ";", "const", "int64_t", "LabelOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "const", "int64_t", "SPOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "PtrLoadOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "MOV64rm", ":", "X86", "::", "MOV32rm", ";", "unsigned", "IJmpOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "JMP64r", ":", "X86", "::", "JMP32r", ";", "MachineBasicBlock", "*", "thisMBB", "=", "MBB", ";", "if", "(", "MF", "->", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "<STR_LIT>", "cf-protection-return", "<STR_LIT>", ")", ")", "{", "thisMBB", "=", "emitLongJmpShadowStackFix", "(", "MI", ",", "thisMBB", ")", ";", "}", "MIB", "=", "BuildMI", "(", "*", "thisMBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "FP", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "MIB", ".", "addReg", "(", "MO", ".", "getReg", "(" ]

[ "OtherVT", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32", ">", "]", ">", ";" ]

[ "def", "SDT_ARMBrcond", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<", "<NUM_LIT>", "," ]

[ "AddrList", ".", "emplace_back", "(", "CI", ")", ";" ]

[ "for", "(", "std", "::", "list", "<", "CombineInfo", ">", "&", "AddrList", ":", "MergeableInsts", ")", "{", "if", "(", "AddrList", ".", "front", "(", ")", ".", "InstClass", "==", "CI", ".", "InstClass", "&&", "AddrList", ".", "front", "(", ")", ".", "hasSameBaseAddress", "(", "*", "CI", ".", "I", ")", ")", "{" ]

[ "<FIXS>", "static", "Value", "*", "isSSATMinMaxPattern", "(", "Instruction", "*", "Inst", ",", "const", "APInt", "&", "Imm", ")", "{", "<FIXE>" ]

[ "}", "<BUGS>", "static", "bool", "isSSATMinMaxPattern", "(", "Instruction", "*", "Inst", ",", "const", "APInt", "&", "Imm", ")", "{", "<BUGE>", "Value", "*", "LHS", ",", "*", "RHS", ";", "ConstantInt", "*", "C", ";", "SelectPatternFlavor", "InstSPF", "=", "matchSelectPattern", "(", "Inst", ",", "LHS", ",", "RHS", ")", ".", "Flavor", ";" ]

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps" ]

[ "}" ]

[ "auto", "T", "=", "const_cast", "<", "Type", "*", ">", "(", "CP", "->", "getType", "(", ")", ")", ";", "auto", "C", "=", "const_cast", "<", "Constant", "*", ">", "(", "CP", "->", "getConstVal", "(", ")", ")", ";", "auto", "M", "=", "const_cast", "<", "Module", "*", ">", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ";", "auto", "GV", "=", "new", "GlobalVariable", "(", "*", "M", ",", "T", ",", "true", ",", "GlobalVariable", "::", "InternalLinkage", ",", "C", ",", "Twine", "(", "DAG", ".", "getDataLayout", "(", ")", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "<STR_LIT>", "CP", "<STR_LIT>", "+", "Twine", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunctionNumber", "(", ")", ")", "+", "<STR_LIT>", "_", "<STR_LIT>", "+", "Twine", "(", "AFI", "->", "createPICLabelUId", "(", ")", ")", ")", ";", "SDValue", "GA", "=", "DAG", ".", "getTargetGlobalAddress", "(", "dyn_cast", "<", "GlobalValue", ">", "(", "GV", ")", ",", "dl", ",", "PtrVT", ")", ";", "return", "LowerGlobalAddress", "(", "GA", ",", "DAG", ")", ";" ]

[ ",", "Cst", ",", "Cst", ",", "Cst", "}", ";" ]

[ "assert", "(", "VT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Expected a vector type", "<STR_LIT>", ")", ";", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstant", "(", "~", "<NUM_LIT>", "U", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Vec", ";", "if", "(", "VT", ".", "is256BitVector", "(", ")", ")", "{", "if", "(", "HasInt256", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "Cst", ",", "Cst", ",", "Cst", ",", "Cst", ",", "Cst" ]

[ "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", ",", "int", "caller", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "NULL", ";", "struct", "cgraph_node", "*", "target", "=", "NULL", ";", "memset", "(", "cum", ",", "<NUM_LIT>", ",", "sizeof", "(", "*", "cum", ")", ")", ";", "if", "(", "fndecl", ")", "{", "target", "=", "cgraph_node", "::", "get", "(", "fndecl", ")", ";", "if", "(", "target", ")", "{", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "i", "=", "cgraph_node", "::", "local_info", "(", "target", "->", "decl", ")", ";", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "target", "->", "decl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "fndecl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_type_abi", "(", "fntype", ")", ";", "cum", "->", "caller", "=", "caller", ";", "cum", "->", "nregs", "=", "ix86_regparm", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "}", "if", "(", "TARGET_SSE", ")", "{", "cum", "->", "sse_nregs", "=", "SSE_REGPARM_MAX", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "sse_nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_SSE_REGPARM_MAX", ":", "X86_64_MS_SSE_REGPARM_MAX", ")", ";", "}", "}", "if", "(", "TARGET_MMX", ")", "cum", "->", "mmx_nregs", "=", "MMX_REGPARM_MAX", ";", "cum", "->", "warn_avx512f", "=", "true", ";", "cum", "->", "warn_avx", "=", "true", ";", "cum", "->", "warn_sse", "=", "true", ";", "cum", "->", "warn_mmx", "=", "true", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "fntype", "=", "TREE_TYPE", "(", "target", "->", "decl", ")", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "maybe_vaarg", "=", "(", "fntype", "?", "(", "!", "prototype_p", "(", "fntype", ")", "||", "stdarg_p", "(", "fntype", ")", ")", ":", "!", "libname", ")", ";", "cum", "->", "bnd_regno", "=", "FIRST_BND_REG", ";", "cum", "->", "bnds_in_bt", "=", "<NUM_LIT>", ";", "cum", "->", "force_bnd_pass", "=", "<NUM_LIT>", ";", "cum", "->", "decl", "=", "fndecl", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "{", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "cfun", "->", "machine", "->", "arg_reg_available", "=", "true", ";", "cum", "->", "sse_nregs", "=", "<NUM_LIT>", ";", "cum", "->", "mmx_nregs", "=", "<NUM_LIT>", ";", "cum", "->", "warn_avx512f", "=", "false", ";", "cum", "->", "warn_avx", "=", "false", ";", "cum", "->", "warn_sse", "=", "false", ";", "cum", "->", "warn_mmx", "=", "false", ";", "return", ";", "}", "if", "(", "fntype", ")", "{", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "fntype", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "<NUM_LIT>", ")", "{", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "cum", "->", "fastcall", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "<NUM_LIT>", ")", "{", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "cum", "->", "fastcall", "=", "<NUM_LIT>", ";", "}", "else", "cum", "->", "nregs", "=", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", ";", "}", "cum", "->", "float_in_sse", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fndecl", ",", "true", ")", ";", "}", "cfun", "->", "machine", "->", "arg_reg_available", "=", "(", "cum", "->", "nregs", ">", "<NUM_LIT>", ")", ";", "}" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "=", "Zn", ";" ]

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

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

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

[ "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

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

[ "let", "Defs", "=", "[", "RAX", ",", "EFLAGS", "]", ",", "Uses", "=", "[", "RAX", "]", "in", "{", "def", "LCMPXCHG64", ":", "RI", "<NUM_LIT>", ",", "MRMDestMem", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "ptr", ",", "GR64", ":", "$", "swap", ")", ",", "<BUGS>", "<STR_LIT>", ",", "<BUGE>", "[", "(", "X86cas", "addr", ":", "$", "ptr", ",", "GR64", ":", "$", "swap", ",", "<NUM_LIT>", ")", "]", ">", ",", "TB", ",", "LOCK", ";", "}", "let", "Constraints", "=", "<STR_LIT>", "in", "{", "let", "Defs", "=", "[", "EFLAGS", "]", "indef", "LXADD64", ":", "RI", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "ptr", ",", "GR64", ":", "$", "val", ")", ",", "<BUGS>", "<STR_LIT>", ",", "<BUGE>", "[", "(", "set", "GR64", ":", "$", "dst", ",", "(", "atomic_load_add_64", "addr", ":", "$", "ptr", ",", "GR64", ":", "$", "val", ")", ")", "]", ">", ",", "TB", ",", "LOCK", ";", "def", "XCHG64rm", ":", "RI", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "ptr", ",", "GR64", ":", "$", "val", ")", "," ]

[ "static", "bool", "rs6000_debug_secondary_memory_needed", "(", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ",", "machine_mode", "mode", ")", "{", "bool", "ret", "=", "rs6000_secondary_memory_needed", "(", "from_class", ",", "to_class", ",", "mode", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "rs6000_secondary_memory_needed, return: %s, from_class = %s, ", "<STR_LIT>", "<STR_LIT>", "to_class = %s, mode = %s\\n", "<STR_LIT>", ",", "ret", "?", "<STR_LIT>", "true", "<STR_LIT>", ":", "<STR_LIT>", "false", "<STR_LIT>", ",", "reg_class_names", "[", "from_class", "]", ",", "reg_class_names", "[", "to_class", "]", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "return", "ret", ";", "}" ]

[ "Debug", "version", "of", "rs6000_secondary_memory_needed", "." ]

[ "(", ")", "{" ]

[ "MRT", "*", "getExitTree" ]

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

[ "if", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "cfun", "->", "calls_alloca", "&&", "regno", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "rtx", "mem", ";", "if", "(", "!", "IN_RANGE", "(", "fp_offset", ",", "-", "<NUM_LIT>", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "break", ";", "else", "{", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "hard_frame_pointer_rtx", ",", "fp_offset", "-", "<NUM_LIT>", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "mem", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "MB_PIPE_5", ")", ")", ")" ]

[ "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "SISubtarget", "&", "STM", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", ".", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Running SILoadStoreOptimizer\\n", "<STR_LIT>", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}" ]

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

[ ")", ";" ]

[ "return", "true", ";", "default", ":", "return", "canGuaranteeTCO", "(", "CC" ]

[ "value", ")", ">", ",", "Requires", "<", "[", "IsBE", "]", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "non_word_alignedstore", "(", "f64", "DPR", ":", "$", "value", ")", ",", "addrmode6", ":", "$", "addr", ")", ",", "(", "VST1d64", "addrmode6", ":", "$", "addr", ",", "DPR", ":", "$" ]

[ "[", "i", "]", ",", "NumElts", "/", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "!=", "<NUM_LIT>", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", "/", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "!", "isUndefOrEqual", "(", "Mask", "[", "i", "]", ",", "<NUM_LIT>", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "NumElts", "/", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "if", "(", "!", "isUndefOrEqual", "(", "Mask" ]

[ "}" ]

[ "def", "off3", ":", "Operand", "<", "i16", ">", ",", "ImmLeaf", "<", "i16", ",", "[", "{", "return", "AAP", ":", ":", "isOff3", "(", "Imm", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "off3AsmOperand", ";" ]

[ "_", "_", "v4df", ")", "_", "_", "B", ",", "(", "_", "_", "v4df", ")", "_", "_", "C", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_fmadd_pd", "(", "_", "_", "m256d", "_", "_", "A", ",", "_", "_", "m256d", "_", "_", "B", ",", "_", "_", "m256d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_vfmaddpd256", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(" ]

[ "let", "OperandType", "=", "<STR_LIT>", ";" ]

[ "let", "ParserMatchClass", "=", "PPCU5ImmAsmOperand", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ ">", ",", "GIComplexPatternEquiv", "<", "neg_addsub_shifted_imm32", ">", ";" ]

[ "def", "gi_neg_addsub_shifted_imm32", ":", "GIComplexOperandMatcher", "<", "s32", ",", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "if", "(", "!", "isImm", ")", "Imm8", "=", "getARMRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "const", "MCOperand", "&", "MO1", "=", "MI", ".", "getOperand", "(", "OpIdx", "+", "<NUM_LIT>", ")", ";", "unsigned", "Imm", "=", "MO1", ".", "getImm", "(", ")", ";", "bool", "isAdd", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "bool", "isImm", "=", "MO", ".", "getReg", "(", ")", "==", "<NUM_LIT>", ";", "uint32_t", "Imm8", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "rotatert", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "plus", ":", "DI", "(", "zero_extend", ":", "DI" ]

[ "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "ltu", ":", "DI", "(", "reg", ":", "CC_C", "CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

[ "return", "ScaledMask", ";" ]

[ "uint64_t", "ScaledMask", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Size", ";", "++", "i", ")", "if", "(", "BlendMask", "&", "(", "<NUM_LIT>", "ull", "<<", "i", ")", ")", "ScaledMask", "|=", "(", "(", "<NUM_LIT>", "ull", "<<", "Scale", ")", "-", "<NUM_LIT>", ")", "<<", "(", "i", "*", "Scale", ")", ";" ]

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

[ "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "<NUM_LIT>", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "Subtarget", ".", "getRegisterInfo", "(", ")", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "<NUM_LIT>", ")", "&&", "FrameSize", "<=", "<NUM_LIT>", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "<NUM_LIT>", ")", ";" ]

[ "bool", "AArch64TargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "CallLoweringInfo", "&", "CLI", ")", "const", "{", "CallingConv", "::", "ID", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ")", ")", "return", "false", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "const", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "const", "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "const", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "&", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", ".", "getCallingConv", "(", ")", ";", "if", "(", "(", "CallerCC", "==", "CallingConv", "::", "C", "||", "CallerCC", "==", "CallingConv", "::", "Fast", ")", "&&", "AArch64RegisterInfo", "::", "hasSVEArgsOrReturn", "(", "&", "MF", ")", ")", "CallerCC", "=", "CallingConv", "::", "AArch64_SVE_VectorCall", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "CallerCC", "==", "CallingConv", "::", "Win64", "&&", "!", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "CalleeCC", "!=", "CallingConv", "::", "Win64", ")", "return", "false", ";", "for", "(", "Function", "::", "const_arg_iterator", "i", "=", "CallerF", ".", "arg_begin", "(", ")", ",", "e", "=", "CallerF", ".", "arg_end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "->", "hasByValAttr", "(", ")", ")", "return", "false", ";", "if", "(", "i", "->", "hasInRegAttr", "(", ")", ")", "return", "false", ";", "}", "if", "(", "canGuaranteeTCO", "(", "CalleeCC", ",", "getTargetMachine", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ")", "return", "CCMatch", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "const", "Triple", "&", "TT", "=", "getTargetMachine", "(", ")", ".", "getTargetTriple", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "TT", ".", "isOSBinFormatELF", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "return", "false", ";", "}", "assert", "(", "(", "!", "IsVarArg", "||", "CalleeCC", "==", "CallingConv", "::", "C", ")", "&&", "<STR_LIT>", "Unexpected variadic calling convention", "<STR_LIT>", ")", ";", "LLVMContext", "&", "C", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "if", "(", "!", "CCState", "::", "resultsCompatible", "(", "CalleeCC", ",", "CallerCC", ",", "MF", ",", "C", ",", "Ins", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "IsVarArg", ")", ",", "CCAssignFnForCall", "(", "CallerCC", ",", "IsVarArg", ")", ")", ")", "return", "false", ";", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "!", "CCMatch", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "Subtarget", "->", "hasCustomCallingConv", "(", ")", ")", "{", "TRI", "->", "UpdateCustomCallPreservedMask", "(", "MF", ",", "&", "CallerPreserved", ")", ";", "TRI", "->", "UpdateCustomCallPreservedMask", "(", "MF", ",", "&", "CalleePreserved", ")", ";", "}", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "if", "(", "Outs", ".", "empty", "(", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "C", ")", ";", "analyzeCallOperands", "(", "*", "this", ",", "Subtarget", ",", "CLI", ",", "CCInfo", ")", ";", "if", "(", "IsVarArg", "&&", "!", "(", "CLI", ".", "CB", "&&", "CLI", ".", "CB", "->", "isMustTailCall", "(", ")", ")", ")", "{", "for", "(", "const", "CCValAssign", "&", "ArgLoc", ":", "ArgLocs", ")", "if", "(", "!", "ArgLoc", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "}", "const", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "llvm", "::", "any_of", "(", "ArgLocs", ",", "[", "]", "(", "CCValAssign", "&", "A", ")", "{", "assert", "(", "(", "A", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Indirect", "||", "A", ".", "getValVT", "(", ")", ".", "isScalableVector", "(", ")", ")", "&&", "<STR_LIT>", "Expected value to be scalable", "<STR_LIT>", ")", ";", "return", "A", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ";", "}", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ">", "FuncInfo", "->", "getBytesInStackArgArea", "(", ")", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "parametersInCSRMatch", "(", "MRI", ",", "CallerPreserved", ",", "ArgLocs", ",", "OutVals", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

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

[ "}" ]

[ "Res", "->", "Tok", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Res", "->", "Tok", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Res", "->", "StartLoc", "=", "Loc", ";", "Res", "->", "EndLoc", "=", "Loc", ";", "return", "Res", ";" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "bit_off", ";", "bits", "<", "<NUM_LIT>", ">", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_off", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";" ]

[ "}" ]

[ "def", "uimm7", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "(", "N", "-", ">", "getZExtValue", "(", ")", "<", "=", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "immSExt8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "int", "Value", "=", "int", "(", "N", "-", ">", "getSExtValue", "(", ")", ")", ";", "return", "(", "Value", ">", "=", "-", "(", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", "&", "&", "Value", "<", "=", "(", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "immU8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "(", "N", "-", ">", "getZExtValue", "(", ")", "<", "=", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "i32ImmSExt10", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isI32IntS10Immediate", "(", "N", ")", ";", "}", "]", ">", ";", "def", "i32ImmUns10", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isI32IntU10Immediate", "(", "N", ")", ";", "}", "]", ">", ";", "def", "i16ImmSExt10", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isI16IntS10Immediate", "(", "N", ")", ";", "}", "]", ">", ";", "def", "i16ImmUns10", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isI16IntU10Immediate", "(", "N", ")", ";", "}", "]", ">", ";", "def", "immSExt16", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "short", "Ignored", ";", "return", "isIntS16Immediate", "(", "N", ",", "Ignored", ")", ";", "}", "]", ">", ";", "def", "immZExt16", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "(", "uint64_t", ")", "N", "-", ">", "getZExtValue", "(", ")", "=", "=", "(", "unsigned", "short", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "}", "]", ",", "LO16", ">", ";", "def", "immU16", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "(", "uint64_t", ")", "N", "-", ">", "getZExtValue", "(", ")", "=", "=", "(", "N", "-", ">", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", ";", "}", "]", ">", ";", "def", "imm18", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "int", "Value", "=", "(", "int", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "isUInt", "<", "<NUM_LIT>", ">", "(", "Value", ")", ";", "}", "]", ">", ";", "def", "lo16", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "if", "(", "N", "-", ">", "getValueType", "(", "<NUM_LIT>", ")", "=", "=", "MVT", ":", ":", "i32", ")", "{", "uint32_t", "val", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "(", "(", "val", "&", "<NUM_LIT>", ")", "=", "=", "val", ")", ";" ]

[ ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "_", "_", "builtin_ia32_vcvttph2qq256_mask", "(", "_", "_", "A", ",", "_", "mm256_setzero_si256", "(" ]

[ "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "reg", ":", "SI", "FPSCR_MODES_REG", ")", ")", "(", "use", "(", "reg", ":", "SI", "PIC_REG", ")", ")" ]

[ "<FIXS>", "static", "char", "savres_routine_name", "[", "<NUM_LIT>", "]", ";", "static", "char", "*", "rs6000_savres_routine_name", "(", "rs6000_stack_t", "*", "info", ",", "int", "regno", ",", "bool", "savep", ",", "bool", "gpr", ",", "bool", "lr", ")", "{", "const", "char", "*", "prefix", "=", "<STR_LIT>", "<STR_LIT>", ";", "const", "char", "*", "suffix", "=", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "TARGET_SPE", ")", "{", "gcc_assert", "(", "gpr", ")", ";", "if", "(", "savep", ")", "prefix", "=", "info", "->", "spe_64bit_regs_used", "?", "<STR_LIT>", "_save64gpr_", "<STR_LIT>", ":", "<STR_LIT>", "_save32gpr_", "<STR_LIT>", ";", "elseprefix", "=", "info", "->", "spe_64bit_regs_used", "?", "<STR_LIT>", "_rest64gpr_", "<STR_LIT>", ":", "<STR_LIT>", "_rest32gpr_", "<STR_LIT>", ";", "if", "(", "lr", ")", "suffix", "=", "<STR_LIT>", "_x", "<STR_LIT>", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "if", "(", "TARGET_64BIT", ")", "goto", "aix_names", ";", "if", "(", "gpr", ")", "prefix", "=", "savep", "?", "<STR_LIT>", "_savegpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restgpr_", "<STR_LIT>", ";", "elseprefix", "=", "savep", "?", "<STR_LIT>", "_savefpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restfpr_", "<STR_LIT>", ";", "if", "(", "lr", ")", "suffix", "=", "<STR_LIT>", "_x", "<STR_LIT>", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "#", "ifndef", "POWERPC_LINUXgcc_assert", "(", "!", "TARGET_AIX", "||", "!", "gpr", ")", ";", "#", "endifaix_names", ":", "if", "(", "gpr", ")", "prefix", "=", "(", "savep", "?", "(", "lr", "?", "<STR_LIT>", "_savegpr0_", "<STR_LIT>", ":", "<STR_LIT>", "_savegpr1_", "<STR_LIT>", ")", ":", "(", "lr", "?", "<STR_LIT>", "_restgpr0_", "<STR_LIT>", ":", "<STR_LIT>", "_restgpr1_", "<STR_LIT>", ")", ")", ";", "#", "ifdef", "POWERPC_LINUXelse", "if", "(", "lr", ")", "prefix", "=", "(", "savep", "?", "<STR_LIT>", "_savefpr_", "<STR_LIT>", ":", "<STR_LIT>", "_restfpr_", "<STR_LIT>", ")", ";", "#", "endifelse", "{", "prefix", "=", "savep", "?", "SAVE_FP_PREFIX", ":", "RESTORE_FP_PREFIX", ";", "suffix", "=", "savep", "?", "SAVE_FP_SUFFIX", ":", "RESTORE_FP_SUFFIX", ";", "}", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "sorry", "(", "<STR_LIT>", "Out-of-line save/restore routines not supported on Darwin", "<STR_LIT>", ")", ";", "sprintf", "(", "savres_routine_name", ",", "<STR_LIT>", "%s%d%s", "<STR_LIT>", ",", "prefix", ",", "regno", ",", "suffix", ")", ";", "return", "savres_routine_name", ";", "}", "?", "(", "info", "->", "spe_64bit_regs_used", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ":", "(", "gpr", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", "<<", "<NUM_LIT>", ")", "|", "(", "lr", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "<FIXE>", "<FIXS>", "gcc_assert", "(", "FIRST_SAVRES_REGISTER", "<=", "regno", "&&", "regno", "<=", "LAST_SAVRES_REGISTER", ")", ";", "<FIXE>", "<FIXS>", "char", "*", "name", ";", "<FIXE>", "<FIXS>", "name", "=", "rs6000_savres_routine_name", "(", "info", ",", "regno", ",", "savep", ",", "gpr", ",", "lr", ")", ";", "<FIXE>" ]

[ "static", "GTY", "(", "(", ")", ")", "rtx", "savres_routine_syms", "[", "N_SAVRES_REGISTERS", "]", "[", "<NUM_LIT>", "]", ";", "<BUGS>", "static", "rtx", "<BUGS>", "rs6000_savres_routine_sym", "(", "rs6000_stack_t", "*", "info", ",", "bool", "savep", ",", "bool", "gpr", ",", "bool", "exitp", ")", "<BUGE>", "{", "int", "regno", "=", "gpr", "?", "info", "->", "first_gp_reg_save", ":", "(", "info", "->", "first_fp_reg_save", "-", "<NUM_LIT>", ")", ";", "rtx", "sym", ";", "int", "select", "=", "(", "(", "savep", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "<BUGS>", "|", "(", "gpr", "?", "(", "TARGET_SPE_ABI", "&&", "info", "->", "spe_64bit_regs_used", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ":", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "(", "exitp", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "<BUGS>", "gcc_assert", "(", "FIRST_SAVRES_REGISTER", "<=", "regno", "&&", "regno", "<=", "LAST_SAVRES_REGISTER", ")", ";", "<BUGE>", "sym", "=", "savres_routine_syms", "[", "regno", "-", "FIRST_SAVRES_REGISTER", "]", "[", "select", "]", ";", "if", "(", "sym", "==", "NULL", ")", "{", "<BUGS>", "char", "name", "[", "<NUM_LIT>", "]", ";", "const", "char", "*", "action", ";", "const", "char", "*", "regkind", ";", "const", "char", "*", "exit_suffix", ";", "action", "=", "savep", "?", "<STR_LIT>", "save", "<STR_LIT>", ":", "<STR_LIT>", "rest", "<STR_LIT>", ";", "<BUGE>", "<BUGS>", "if", "(", "TARGET_SPE_ABI", ")", "{", "gcc_assert", "(", "gpr", ")", ";", "regkind", "=", "info", "->", "spe_64bit_regs_used", "?", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "}", "elseregkind", "=", "gpr", "?", "<STR_LIT>", "gpr", "<STR_LIT>", ":", "<STR_LIT>", "fpr", "<STR_LIT>", ";", "exit_suffix", "=", "exitp", "?", "<STR_LIT>", "_x", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ";", "sprintf", "(", "name", ",", "<STR_LIT>", "_%s%s_%d%s", "<STR_LIT>", ",", "action", ",", "regkind", ",", "regno", ",", "exit_suffix", ")", ";", "<BUGE>", "sym", "=", "savres_routine_syms", "[", "regno", "-", "FIRST_SAVRES_REGISTER", "]", "[", "select", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "name", ")", ")", ";", "}", "return", "sym", ";" ]

[ "<FIXS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "*", "<NUM_LIT>", ")", ")", ";", "<FIXE>", "<FIXS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "*", "<NUM_LIT>", ")", ")", ";", "<FIXE>", "<FIXS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "*", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "break", ";", "case", "Mips", "::", "LD_H", ":", "case", "Mips", "::", "ST_H", ":", "<BUGS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "<<", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "break", ";", "case", "Mips", "::", "LD_W", ":", "case", "Mips", "::", "ST_W", ":", "<BUGS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "<<", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "break", ";", "case", "Mips", "::", "LD_D", ":", "case", "Mips", "::", "ST_D", ":", "<BUGS>", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Offset", "<<", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "break", ";", "}" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "MCE", "->", "getValue", "(", ")", ">>", "<NUM_LIT>", ")", ")", ";" ]

[ "addExpr", "(", "Inst", ",", "getImm", "(", ")", ")", ";", "return", ";", "}", "assert", "(", "MCE", "&&", "<STR_LIT>", "Invalid constant immediate operand!", "<STR_LIT>", ")", ";" ]

[ "false", ";" ]

[ "if", "(", "check", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "AbiVersion", ")", ",", "L", ",", "<STR_LIT>", "expected constant expression", "<STR_LIT>", ")", "||", "parseToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "addErrorSuffix", "(", "<STR_LIT>", " in '.abiversion' directive", "<STR_LIT>", ")", ";", "PPCTargetStreamer", "*", "TStreamer", "=", "static_cast", "<", "PPCTargetStreamer", "*", ">", "(", "getParser", "(", ")", ".", "getStreamer", "(", ")", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "TStreamer", "!=", "nullptr", ")", "TStreamer", "->", "emitAbiVersion", "(", "AbiVersion", ")", ";", "return" ]

[ "STRDpre", "FPR64", ":", "$", "Rt", ",", "GPR64sp", ":", "$", "addr", ",", "simm9", ":", "$", "off", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "pre_store", "(", "v2f32", "FPR64", ":", "$", "Rt", ")", ",", "GPR64sp", ":", "$", "addr", ",", "simm9", ":", "$", "off", ")", ",", "(" ]

[ "false", ";" ]

[ "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "true", ";", "if", "(", "isTargetMachO", "(", ")", "&&", "TM", ".", "isPositionIndependent", "(", ")", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "true", ";", "return" ]

[ "void", "SPUTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "Opc", "=", "(", "unsigned", ")", "N", "->", "getOpcode", "(", ")", ";", "MVT", "OpVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "{", "cerr", "<<", "<STR_LIT>", "SPUTargetLowering::ReplaceNodeResults(): need to fix this!\\n", "<STR_LIT>", ";", "cerr", "<<", "<STR_LIT>", "Op.getOpcode() = ", "<STR_LIT>", "<<", "Opc", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "cerr", "<<", "<STR_LIT>", "*Op.getNode():\\n", "<STR_LIT>", ";", "N", "->", "dump", "(", ")", ";", "abort", "(", ")", ";", "}", "}", "}" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "=", "VectorPred", ";" ]

[ "class", "TPCInstLoad", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ">", ":", "LoadInstGeneric", "<", "opc", ",", "asmstr", ">", "{", "bits", "<", "<NUM_LIT>", ">", "SrcA", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Dest", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SrcExtra", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PredPolarity", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PredAddress", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "VectorPred", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Switches", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcA", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Dest", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredPolarity", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "PredAddress", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]