Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>", ")" ]

[ "(", "ior", ":", "QI", "(", "subreg", ":", "QI", "(", "ashift", ":", "SI", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "else", "if", "(", "DestReg", ">=", "PPC", "::", "CR4LT", "||", "DestReg", "<=", "PPC", "::", "CR4UN", ")", "Reg", "=", "PPC", "::", "CR4", ";" ]

[ "}", "else", "{", "NewMIs", ".", "push_back", "(", "addFrameReference", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "LD", ")", ",", "PPC", "::", "R11", ")", ",", "FrameIdx", ")", ")", ";", "NewMIs", ".", "push_back", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "MTLR8", ")", ")", ".", "addReg", "(", "PPC", "::", "R11", ")", ")", ";", "}", "}", "else", "if", "(", "RC", "==", "PPC", "::", "F8RCRegisterClass", ")", "{", "NewMIs", ".", "push_back", "(", "addFrameReference", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "LFD", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "PPC", "::", "F4RCRegisterClass", ")", "{", "NewMIs", ".", "push_back", "(", "addFrameReference", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "LFS", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "PPC", "::", "CRRCRegisterClass", ")", "{", "NewMIs", ".", "push_back", "(", "addFrameReference", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "LWZ", ")", ",", "PPC", "::", "R0", ")", ",", "FrameIdx", ")", ")", ";", "if", "(", "DestReg", "!=", "PPC", "::", "CR0", ")", "{", "unsigned", "ShiftBits", "=", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "DestReg", ")", "*", "<NUM_LIT>", ";", "NewMIs", ".", "push_back", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "RLWINM", ")", ",", "PPC", "::", "R0", ")", ".", "addReg", "(", "PPC", "::", "R0", ")", ".", "addImm", "(", "<NUM_LIT>", "-", "ShiftBits", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "}", "NewMIs", ".", "push_back", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "MTCRF", ")", ",", "DestReg", ")", ".", "addReg", "(", "PPC", "::", "R0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "PPC", "::", "CRBITRCRegisterClass", ")", "{", "unsigned", "Reg", "=", "<NUM_LIT>", ";", "if", "(", "DestReg", ">=", "PPC", "::", "CR0LT", "||", "DestReg", "<=", "PPC", "::", "CR0UN", ")", "Reg", "=", "PPC", "::", "CR0", ";", "else", "if", "(", "DestReg", ">=", "PPC", "::", "CR1LT", "||", "DestReg", "<=", "PPC", "::", "CR1UN", ")", "Reg", "=", "PPC", "::", "CR1", ";", "else", "if", "(", "DestReg", ">=", "PPC", "::", "CR2LT", "||", "DestReg", "<=", "PPC", "::", "CR2UN", ")", "Reg", "=", "PPC", "::", "CR2", ";", "else", "if", "(", "DestReg", ">=", "PPC", "::", "CR3LT", "||", "DestReg", "<=", "PPC", "::", "CR3UN", ")", "Reg", "=", "PPC", "::", "CR3", ";" ]

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

[ "unsigned", "bit", ",", "shf", ",", "rot", ";", "if", "(", "const_ok_for_mcore", "(", "value", ")", ")", "<BUGS>", "return", "<NUM_LIT>", ";", "<BUGE>", "if", "(", "TARGET_HARDLIT", ")", "{" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "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>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt2", ";" ]

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

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

[ "_", "_", "hint", ")", ";" ]

[ "_", "_", "builtin_ia32_scatterpfqpd", "(", "_", "_", "mask", ",", "(", "_", "_", "v8di", ")", "_", "_", "index", ",", "_", "_", "addr", ",", "_", "_", "scale", "," ]

[ "<FIXS>", "gcc_assert", "(", "!", "second_test", ")", ";", "<FIXE>" ]

[ "rtx", "tmp2", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "if", "(", "bypass_test", ")", "{", "<BUGS>", "if", "(", "second_test", ")", "abort", "(", ")", ";", "<BUGE>", "test", "=", "bypass_test", ";", "bypass", "=", "<NUM_LIT>", ";", "PUT_CODE", "(", "test", ",", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "test", ")", ")", ")", ";" ]

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

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

[ "<STR_LIT>" ]

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

[ "Kernel", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "unsigned", "X86TargetLowering", "::", "getGlobalWrapperKind", "(", "const", "GlobalValue", "*", "GV", ",", "const", "unsigned", "char", "OpFlags", ")", "const", "{", "if", "(", "GV", "&&", "GV", "->", "isAbsoluteSymbolRef", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "if", "(", "(", "Subtarget", ".", "isPICStyleRIPRel", "(", ")", "||", "Subtarget", ".", "is64Bit", "(", ")", ")", "&&", "(", "M", "==", "CodeModel", "::", "Small", "||", "M", "==", "CodeModel", "::" ]

[ "<FIXS>", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "<FIXE>", "<FIXS>", "MUL", "=", "genFusedMultiplyAccNeg", "(", "MF", ",", "MRI", ",", "TII", ",", "Root", ",", "InsInstrs", ",", "InstrIdxForVirtReg", ",", "<NUM_LIT>", ",", "Opc", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "RC", ")", ";", "<FIXE>" ]

[ "MUL", "=", "genFusedMultiplyAcc", "(", "MF", ",", "MRI", ",", "TII", ",", "Root", ",", "InsInstrs", ",", "<NUM_LIT>", ",", "Opc", ",", "RC", ")", ";", "break", ";", "case", "MachineCombinerPattern", "::", "MULSUBv4i16_OP1", ":", "<BUGS>", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGE>", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGS>", "MUL", "=", "genFusedMultiplyAcc", "(", "MF", ",", "MRI", ",", "TII", ",", "Root", ",", "InsInstrs", ",", "<NUM_LIT>", ",", "Opc", ",", "RC", ")", ";", "<BUGE>", "break", ";", "case", "MachineCombinerPattern", "::", "MULSUBv4i16_OP2", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "if", "(", "!", "select", "(", "ExtrInst", ")", ")", "return", "false", ";" ]

[ "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "NumDefs", ";", "++", "Idx", ")", "{", "MachineInstr", "&", "ExtrInst", "=", "*", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "G_EXTRACT", ")", ",", "I", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "Idx", "*", "DefSize", ")", ";" ]

[ "}" ]

[ "static", "int", "get_element_number", "(", "tree", "vec_type", ",", "tree", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "elt", ",", "max", "=", "TYPE_VECTOR_SUBPARTS", "(", "vec_type", ")", "-", "<NUM_LIT>", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "(", "elt", "=", "tree_to_uhwi", "(", "arg", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "<STR_LIT>", "selector must be an integer constant in the range ", "<STR_LIT>", "<STR_LIT>", "[0, %wi]", "<STR_LIT>", ",", "max", ")", ";", "return", "<NUM_LIT>", ";", "}", "return", "elt", ";" ]

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

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

[ "<FIXS>", "StartInst", "->", "print", "(", "OS", ",", "true", ")", ";", "<FIXE>", "<FIXS>", "LastInst", "->", "print", "(", "OS", ",", "true", ")", ";", "<FIXE>", "<FIXS>", "KillInst", "->", "print", "(", "OS", ",", "true", ")", ";", "<FIXE>" ]

[ "raw_string_ostream", "OS", "(", "S", ")", ";", "OS", "<<", "<STR_LIT>", "{", "<STR_LIT>", ";", "<BUGS>", "StartInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "<BUGE>", "OS", "<<", "<STR_LIT>", " -> ", "<STR_LIT>", ";", "<BUGS>", "LastInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "<BUGE>", "if", "(", "KillInst", ")", "{", "OS", "<<", "<STR_LIT>", " (kill @ ", "<STR_LIT>", ";", "<BUGS>", "KillInst", "->", "print", "(", "OS", ",", "NULL", ",", "true", ")", ";", "<BUGE>", "OS", "<<", "<STR_LIT>", ")", "<STR_LIT>", ";", "}", "OS", "<<", "<STR_LIT>", "}", "<STR_LIT>", ";" ]

[ "Imm0_31Operand", ";" ]

[ "def", "imm0_31", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=" ]

[ "}" ]

[ "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "<NUM_LIT>", ";", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", ")" ]

[ "(", "if_then_else", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "cc0", ")", "(", "compare", "(", "and", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_dup" ]

[ ";" ]

[ "class", "BranchAlways", "<", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "F2_2", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "hasDelaySlot", "=", "<NUM_LIT>", ";", "let", "isBarrier", "=", "<NUM_LIT>" ]

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

[ "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "auto", "FloatY", "=", "B", ".", "buildUITOFP", "(", "S32", ",", "Y", ")", ";", "auto", "RcpIFlag", "=", "B", ".", "buildInstr", "(", "AMDGPU", "::", "G_AMDGPU_RCP_IFLAG", ",", "{", "S32", "}", ",", "{", "FloatY", "}", ")", ";", "auto", "Scale", "=", "B", ".", "buildFConstant", "(", "S32", ",", "BitsToFloat", "(", "<NUM_LIT>", ")", ")", ";", "auto", "ScaledY", "=", "B", ".", "buildFMul", "(", "S32", ",", "RcpIFlag", ",", "Scale", ")", ";", "auto", "Z", "=", "B", ".", "buildFPTOUI", "(", "S32", ",", "ScaledY", ")", ";", "auto", "NegY", "=", "B", ".", "buildSub", "(", "S32", ",", "B", ".", "buildConstant", "(", "S32", ",", "<NUM_LIT>", ")", ",", "Y", ")", ";", "auto", "NegYZ", "=", "B", ".", "buildMul", "(", "S32", ",", "NegY", ",", "Z", ")", ";", "Z", "=", "B", ".", "buildAdd", "(", "S32", ",", "Z", ",", "B", ".", "buildUMulH", "(", "S32", ",", "Z", ",", "NegYZ", ")", ")", ";", "auto", "Q", "=", "B", ".", "buildUMulH", "(", "S32", ",", "X", ",", "Z", ")", ";", "auto", "R", "=", "B", ".", "buildSub", "(", "S32", ",", "X", ",", "B", ".", "buildMul", "(", "S32", ",", "Q", ",", "Y", ")", ")", ";", "auto", "One", "=", "B", ".", "buildConstant", "(", "S32", ",", "<NUM_LIT>", ")", ";", "auto", "Cond", "=", "B", ".", "buildICmp", "(", "CmpInst", "::", "ICMP_UGE", ",", "S1", ",", "R", ",", "Y", ")", ";", "if", "(", "IsDiv", ")", "Q", "=", "B", ".", "buildSelect", "(", "S32", ",", "Cond", ",", "B", ".", "buildAdd", "(", "S32", ",", "Q", ",", "One", ")", ",", "Q", ")", ";", "R", "=", "B", ".", "buildSelect", "(", "S32", ",", "Cond", ",", "B", ".", "buildSub", "(", "S32", ",", "R", ",", "Y", ")" ]

[ "<STR_LIT>", ")" ]

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

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

[ "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "ABI", ".", "GetStackPtr", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "ZERO", "=", "ABI", ".", "GetNullPtr", "(", ")", ";", "unsigned", "MOVE", "=", "ABI", ".", "GetGPRMoveOp", "(", ")", ";", "if", "(", "hasFP", "(", "MF" ]

[ "}" ]

[ "static", "SDValue", "PerformShuffleCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "TargetLowering", "::", "DAGCombinerInfo", "&", "DCI", ",", "const", "X86Subtarget", "*", "Subtarget", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "!", "DCI", ".", "isBeforeLegalize", "(", ")", "&&", "!", "TLI", ".", "isTypeLegal", "(", "VT", ".", "getVectorElementType", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "TLI", ".", "isTypeLegal", "(", "VT", ")", "&&", "Subtarget", "->", "hasSSE3", "(", ")", ")", "if", "(", "SDValue", "AddSub", "=", "combineShuffleToAddSub", "(", "N", ",", "DAG", ")", ")", "return", "AddSub", ";", "if", "(", "Subtarget", "->", "hasFp256", "(", ")", "&&", "VT", ".", "is256BitVector", "(", ")", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "VECTOR_SHUFFLE", ")", "return", "PerformShuffleCombine256", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "if", "(", "!", "DCI", ".", "isBeforeLegalize", "(", ")", "&&", "DCI", ".", "isBeforeLegalizeOps", "(", ")", "&&", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", "&&", "N0", ".", "hasOneUse", "(", ")", "&&", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "SDValue", "BC0", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SVT", "=", "BC0", ".", "getValueType", "(", ")", ";", "unsigned", "Opcode", "=", "BC0", ".", "getOpcode", "(", ")", ";", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "BC0", ".", "hasOneUse", "(", ")", "&&", "SVT", ".", "isVector", "(", ")", "&&", "SVT", ".", "getVectorNumElements", "(", ")", "*", "<NUM_LIT>", "==", "NumElts", "&&", "TLI", ".", "isOperationLegal", "(", "Opcode", ",", "VT", ")", ")", "{", "bool", "CanFold", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "FSUB", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "FMUL", ":", "CanFold", "=", "true", ";", "}", "unsigned", "SVTNumElts", "=", "SVT", ".", "getVectorNumElements", "(", ")", ";", "ShuffleVectorSDNode", "*", "SVOp", "=", "cast", "<", "ShuffleVectorSDNode", ">", "(", "N", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "SVTNumElts", ";", "i", "!=", "e", "&&", "CanFold", ";", "++", "i", ")", "CanFold", "=", "SVOp", "->", "getMaskElt", "(", "i", ")", "==", "(", "int", ")", "(", "i", "*", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "SVTNumElts", ",", "e", "=", "NumElts", ";", "i", "!=", "e", "&&", "CanFold", ";", "++", "i", ")", "CanFold", "=", "SVOp", "->", "getMaskElt", "(", "i", ")", "<", "<NUM_LIT>", ";", "if", "(", "CanFold", ")", "{", "SDValue", "BC00", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "BC0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "BC01", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "BC0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "NewBinOp", "=", "DAG", ".", "getNode", "(", "BC0", ".", "getOpcode", "(", ")", ",", "dl", ",", "VT", ",", "BC00", ",", "BC01", ")", ";", "return", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "dl", ",", "NewBinOp", ",", "N1", ",", "&", "SVOp", "->", "getMask", "(", ")", "[", "<NUM_LIT>", "]", ")", ";", "}", "}", "}", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Elts", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Elts", ".", "push_back", "(", "getShuffleScalarElt", "(", "N", ",", "i", ",", "DAG", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "SDValue", "LD", "=", "EltsFromConsecutiveLoads", "(", "VT", ",", "Elts", ",", "dl", ",", "DAG", ",", "true", ")", ")", "return", "LD", ";", "if", "(", "isTargetShuffle", "(", "N", "->", "getOpcode", "(", ")", ")", ")", "{", "SDValue", "Shuffle", "=", "PerformTargetShuffleCombine", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "if", "(", "Shuffle", ".", "getNode", "(", ")", ")", "return", "Shuffle", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "NonceMask", ";", "NonceMask", ".", "push_back", "(", "<NUM_LIT>", ")", ";", "if", "(", "combineX86ShufflesRecursively", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "NonceMask", ",", "<NUM_LIT>", ",", "false", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "const", "char", "*", "output_return", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "gcc_assert", "(", "!", "final_sequence", ")", ";", "if", "(", "flag_delayed_branch", ")", "{", "if", "(", "!", "TARGET_FLAT", "&&", "TARGET_V9", ")", "fputs", "(", "<STR_LIT>", "\\treturn\\t%i7+8\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "else", "{", "if", "(", "!", "TARGET_FLAT", ")", "fputs", "(", "<STR_LIT>", "\\trestore\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "fputs", "(", "<STR_LIT>", "\\tjmp\\t%o7+8\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "}", "fputs", "(", "<STR_LIT>", "\\t add\\t%sp, %g1, %sp\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "}", "else", "{", "if", "(", "!", "TARGET_FLAT", ")", "fputs", "(", "<STR_LIT>", "\\trestore\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "fputs", "(", "<STR_LIT>", "\\tadd\\t%sp, %g1, %sp\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "fputs", "(", "<STR_LIT>", "\\tjmp\\t%o7+8\\n\\t nop\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "}", "}", "else", "if", "(", "sparc_leaf_function_p", "||", "TARGET_FLAT", ")", "{", "return", "<STR_LIT>", "jmp\\t%%o7+%)%#", "<STR_LIT>", ";", "}", "else", "{", "if", "(", "final_sequence", ")", "{", "rtx_insn", "*", "delay", ";", "rtx", "pat", ";", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "pat", "=", "PATTERN", "(", "delay", ")", ";", "if", "(", "TARGET_V9", "&&", "!", "epilogue_renumber", "(", "&", "pat", ",", "<NUM_LIT>", ")", ")", "{", "epilogue_renumber", "(", "&", "pat", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>", "return\\t%%i7+%)%#", "<STR_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "jmp\\t%%i7+%)", "<STR_LIT>", ",", "NULL", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "<NUM_LIT>", ";", "final_scan_insn", "(", "delay", ",", "asm_out_file", ",", "optimize", ",", "<NUM_LIT>", ",", "NULL", ")", ";", "INSN_LOCATION", "(", "delay", ")", "=", "UNKNOWN_LOCATION", ";", "output_restore", "(", "pat", ")", ";", "}", "}", "else", "{", "if", "(", "TARGET_V9", ")", "return", "<STR_LIT>", "return\\t%%i7+%)\\n\\t nop", "<STR_LIT>", ";", "else", "if", "(", "flag_delayed_branch", ")", "return", "<STR_LIT>", "jmp\\t%%i7+%)\\n\\t restore", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "restore\\n\\tjmp\\t%%o7+%)\\n\\t nop", "<STR_LIT>", ";", "}", "}", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Output", "a", "return", "." ]

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

[ "return", "\\\"movu %1,%0\\\"}return \\\"mov %1,%0\\\"case 3:<BUGS>case 4:<BUGE>return \\\"movhu %1,%0\\\"case 5:<BUGS>case 6:<BUGE>return \\\"fmov %1,%0\\\"default:gcc_unreachable ()}}", "<STR_LIT>", "cc", "<STR_LIT>", "none", ",", "clobber", ",", "none_0hit", ",", "none_0hit", ",", "none_0hit", ",", "none_0hit", ",", "none_0hit", "<STR_LIT>", "<STR_LIT>", "nonimmediate_operand", "<STR_LIT>", "=", "d", "*", "a", ",", "d", ",", "d", ",", "!", "*", "a", ",", "d", "*", "a", ",", "d", ",", "m", "<STR_LIT>", "general_operand", "<STR_LIT>", "<NUM_LIT>", ",", "I", ",", "i", ",", "i", ",", "da", ",", "m", ",", "d", "<STR_LIT>", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "HImode", ")" ]

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

[ "[", "(" ]

[ "}" ]

[ "decl", "=", "add_builtin_function_ext_scope", "(", "ix86_builtins_isa", "[", "i", "]", ".", "name", ",", "type", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "ix86_builtins", "[", "i", "]", "=", "decl", ";", "if", "(", "ix86_builtins_isa", "[", "i", "]", ".", "const_p", ")", "TREE_READONLY", "(", "decl", ")", "=", "<NUM_LIT>", ";", "if", "(", "ix86_builtins_isa", "[", "i", "]", ".", "pure_p", ")", "DECL_PURE_P", "(", "decl", ")", "=", "<NUM_LIT>", ";", "if", "(", "!", "flag_non_call_exceptions", ")", "TREE_NOTHROW", "(", "decl", ")", "=", "<NUM_LIT>", ";", "if", "(", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_MAX", "]", "==", "NULL_TREE", ")", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_MAX", "]", "=", "build_tree_list", "(", "get_identifier", "(", "<STR_LIT>", "leaf", "<STR_LIT>", ")", ",", "NULL_TREE", ")", ";", "DECL_ATTRIBUTES", "(", "decl", ")", "=", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_MAX", "]", ";" ]

[ "}" ]

[ "class", "VLD4D", "<", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", "DPR", ":", "$", "Vd", ",", "DPR", ":", "$", "dst2", ",", "DPR", ":", "$", "dst3", ",", "DPR", ":", "$", "dst4", ")", ",", "(", "ins", "addrmode6", ":", "$", "Rn", ")", ",", "IIC_VLD4", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVLD4", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "(", "<NUM_LIT>", ")", ".", "isTied", "(", ")", ")", "MI", ".", "tieOperands", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "MI", ".", "getDesc", "(", ")", ".", "getOperandConstraint", "(", "<NUM_LIT>", ",", "MCOI", "::", "TIED_TO", ")", "==", "<NUM_LIT>", "&&", "!", "MI", ".", "getOperand" ]

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

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

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

[ "def", "A2_or", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "rtx", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "pred_mode", ",", "op0", ",", "op1", ")", ";" ]

[ "void", "aarch64_expand_sve_vec_cmp_int", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "data_mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "!", "aarch64_sve_cmp_operand_p", "(", "code", ",", "op1", ")", ")", "op1", "=", "force_reg", "(", "data_mode", ",", "op1", ")", ";", "rtx", "ptrue", "=", "force_reg", "(", "pred_mode", ",", "CONSTM1_RTX", "(", "pred_mode", ")", ")", ";" ]

[ "<STR_LIT>", ";" ]

[ "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "<NUM_LIT>", "]", ";", "rtx", "src", "=", "op", "[", "<NUM_LIT>", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_dest", "==", "reg_base", ")", "return", "avr_asm_len", "(", "<STR_LIT>", "ld __tmp_reg__,%1+", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ld %B0,%1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %A0,__tmp_reg__", "<STR_LIT>", ",", "op", ",", "plen", ",", "-", "<NUM_LIT>", ")", ";", "avr_asm_len", "(", "<STR_LIT>", "ld %A0,%1+", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ld %B0,%1", "<STR_LIT>", ",", "op", ",", "plen", ",", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "<NUM_LIT>", ")", ",", "op", ",", "plen", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>" ]

[ "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "<STR_LIT>", "Unexpected data type for Gather/Scatter", "<STR_LIT>", ")", ";", "unsigned", "VF", "=", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", "->", "getNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "cast", "<", "VectorType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "<STR_LIT>", "Unexpected type for Ptr argument", "<STR_LIT>", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "<NUM_LIT>", "||", "(", "VF", "==", "<NUM_LIT>", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "$", "dst", ",", "(", "select", "i1", ":", "$", "cond", ",", "i64", ":", "$", "T", ",", "i64", ":", "$", "F", ")", ")", "]", ">", ";" ]

[ "def", "SELECT_I8", ":", "PPCCustomInserterPseudo", "<", "(", "outs", "g8rc", ":", "$", "dst", ")", ",", "(", "ins", "crbitrc", ":", "$", "cond", ",", "g8rc_nox0", ":", "$", "T", ",", "g8rc_nox0", ":", "$", "F", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "i64", ":" ]

[ "&", "&", "flag_finite_math_only", "&", "&", "!", "flag_trapping_math" ]

[ "<STR_LIT>", "{", "if", "(", "<", "MODE", ">", "mode", "=", "=", "SFmode", "&", "&", "TARGET_SSE", "&", "&", "TARGET_SSE_MATH", "&", "&", "TARGET_RECIP_DIV", "&", "&", "optimize_insn_for_speed_p", "(", ")" ]

[ "(", "V32HF", "<STR_LIT>", ")", "(", "V16HF", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")" ]

[ "(", "define_mode_attr", "avx512fmaskmode", "[", "(", "V64QI", "<STR_LIT>", ")", "(", "V32QI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V32HI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")", "(", "V16SI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V8DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "DI", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "<BUGS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "sign_extend", ":", "DI", "<BUGS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "return", "<STR_LIT>", "else", "return", "<STR_LIT>", "}", "else", "{", "mips_output_load_label", "(", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "TARGET_CB_MAYBE", ")", "return", "<STR_LIT>", "else", "return", "<STR_LIT>", "}", "}", "[", "(", "set_attr", "<STR_LIT>" ]

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

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

[ ";" ]

[ "if", "(", "!", "isTagStore", "(", "MemMI", ")", "&&", "MemMI", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "bool", "IsPairedInsn", "=", "isPairedLdSt", "(", "MemMI", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "IsPairedInsn", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Register", "DestReg", "=", "getLdStRegOp", "(", "MemMI", ",", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "DestReg", "==", "BaseReg", "||", "TRI", "->", "isSubRegister", "(", "BaseReg", ",", "DestReg", ")", ")", "return", "E", ";", "}", "}", "ModifiedRegUnits", ".", "clear", "(", ")", ";", "UsedRegUnits", ".", "clear", "(", ")", ";", "++", "MBBI" ]

[ ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rs", ",", "Addr", ",", "Decoder", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rt2", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rs", ",", "Addr", ",", "Decoder", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeGPR64RegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "DecodeGPR64RegisterClass", "(", "Inst", ",", "Rt2", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "}", "DecodeGPR64spRegisterClass", "(", "Inst", ",", "Rn", ",", "Addr", ",", "Decoder", ")", ";", "if", "(", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "Rt", "==", "Rt2", ")", "return", "SoftFail", ";", "return", "Success" ]

[ "StackOffset", "SystemZELFFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "StackOffset", "Offset", "=", "TargetFrameLowering", "::", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "return", "Offset", "+", "StackOffset", "::", "getFixed", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}" ]

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

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

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

[ "true", ";" ]

[ "CodePointerSize", "=", "CalleeSaveStackSlotSize", "=", "Is64Bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "ZeroDirective", "=", "<STR_LIT>", "\\t.space\\t", "<STR_LIT>", ";", "SymbolsHaveSMC", "=" ]

[ "<FIXS>", "bool", "allow_reg_index_p", "=", "(", "!", "load_store_pair_p", "&&", "(", "maybe_ne", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "<NUM_LIT>", ")", "||", "aarch64_vector_mode_supported_p", "(", "mode", ")", ")", "&&", "!", "aarch64_vect_struct_mode_p", "(", "mode", ")", ")", ";", "<FIXE>" ]

[ "||", "(", "BYTES_BIG_ENDIAN", "&&", "aarch64_vect_struct_mode_p", "(", "mode", ")", ")", ")", ";", "<BUGS>", "bool", "allow_reg_index_p", "=", "!", "load_store_pair_p", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "<NUM_LIT>", "||", "aarch64_vector_mode_supported_p", "(", "mode", ")", ")", "&&", "!", "aarch64_vect_struct_mode_p", "(", "mode", ")", ";", "<BUGE>" ]

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createHexagonConstExtenders", "(", ")", "{", "return", "new", "HexagonConstExtenders", "(", ")", ";" ]

[ "MVT", "::", "f64", ",", "ValueToStore", ")", ";" ]

[ "if", "(", "SrcVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "{", "if", "(", "SrcVT", "==", "MVT", "::", "v2i1", "&&", "TLI", ".", "isTypeLegal", "(", "SrcVT", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "MVT", "::", "v2i64", ",", "Src", ")", ")", ";", "MVT", "IntegerVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "SrcVT", ".", "getVectorNumElements", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "IntegerVT", ",", "Src", ")", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "assert", "(", "SrcVT", "<=", "MVT", "::", "i64", "&&", "SrcVT", ">=", "MVT", "::", "i16", "&&", "<STR_LIT>", "Unknown SINT_TO_FP to lower!", "<STR_LIT>", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i32", "&&", "isScalarFPTypeInSSEReg", "(", "Op", ".", "getValueType", "(", ")", ")", ")", "return", "Op", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "isScalarFPTypeInSSEReg", "(", "Op", ".", "getValueType", "(", ")", ")", "&&", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "return", "Op", ";", "}", "SDValue", "ValueToStore", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "isScalarFPTypeInSSEReg", "(", "Op", ".", "getValueType", "(", ")", ")", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "ValueToStore", "=", "DAG", ".", "getBitcast", "(" ]

[ "Op", ",", "DAG", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", "&&", "!", "Subtarget", "->", "hasMultiDwordFlatScratchAddressing", "(", ")", ")", "AS", "=", "addressMayBeAccessedAsPrivate", "(", "Store", "->", "getMemOperand", "(", ")", ",", "*", "MFI", ")", "?", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ";", "unsigned", "NumElements", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "{", "if", "(", "NumElements", ">", "<NUM_LIT>", ")", "return", "SplitVectorStore", "(", "Op", ",", "DAG", ")", ";", "if", "(", "NumElements", "==", "<NUM_LIT>", "&&", "!", "Subtarget", "->", "hasDwordx3LoadStores", "(", ")", ")", "return", "SplitVectorStore", "(", "Op", ",", "DAG", ")", ";", "if", "(", "!", "allowsMemoryAccessForAlignment", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "DAG", ".", "getDataLayout", "(", ")", ",", "VT", ",", "*", "Store", "->", "getMemOperand", "(", ")", ")", ")", "return", "expandUnalignedStore", "(", "Store", ",", "DAG", ")", ";", "return", "SDValue", "(", ")", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "{", "switch", "(", "Subtarget", "->", "getMaxPrivateElementSize", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "return", "scalarizeVectorStore", "(", "Store", ",", "DAG", ")", ";", "case", "<NUM_LIT>", ":", "if", "(", "NumElements", ">", "<NUM_LIT>", ")", "return", "SplitVectorStore", "(" ]

[ "<FIXS>", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "CLOBBER", ")", "<FIXE>" ]

[ "if", "(", "(", "!", "NONJUMP_INSN_P", "(", "anchor", ")", "&&", "!", "JUMP_P", "(", "anchor", ")", "&&", "!", "CALL_P", "(", "anchor", ")", ")", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "USE", "<BUGS>", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "ADDR_DIFF_VEC", ")", "<BUGE>", "continue", ";", "anchor_attr", "=", "get_attr_pa_combine_type", "(", "anchor", ")", ";" ]

[ "assert", "(", "(", "(", "Imm", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Lower 6 bits must be ZERO.", "<STR_LIT>", ")", ";" ]

[ "bool", "Success", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getExpr", "(", ")", "->", "evaluateAsAbsolute", "(", "Imm", ")", ";", "Imm", "=", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ";", "assert", "(", "Success", ")", ";", "(", "void", ")", "Success", ";" ]

[ "v2f32", ">", ";" ]

[ "def", ":", "ConcatPat", "<", "v4f32", "," ]

[ "let", "Constraints", "=", "cstr", ";" ]

[ "Format", "F", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "Form", "=", "F", ".", "Value", ";", "bit", "isWhile", "=", "<NUM_LIT>", ";", "bit", "isPTestLike", "=", "<NUM_LIT>", ";", "FalseLanesEnum", "FalseLanes", "=", "FalseLanesNone", ";", "DestructiveInstTypeEnum", "DestructiveInstType", "=", "NotDestructive", ";", "ElementSizeEnum", "ElementSize", "=", "ElementSizeNone", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "isPTestLike", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "isWhile", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "FalseLanes", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "DestructiveInstType", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ElementSize", ".", "Value", ";", "let", "Pattern", "=", "[", "]", ";" ]

[ "assemble_name", "(", "file", ",", "buf", ")", ";" ]

[ "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tmflr %s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\taddi %s,%s,4\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "fputs", "(", "<STR_LIT>", "\\tbcl 20,31,1f\\n\\t.long ", "<STR_LIT>", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fputs", "(", "<STR_LIT>", "-.\\n1:", "<STR_LIT>", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tmflr %s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tlwz %s,0(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd %s,%s,%s\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tlis %s,", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fputs", "(", "<STR_LIT>", "@ha\\n", "<STR_LIT>", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tstw %s,4(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "\\tla %s,", "<STR_LIT>", ",", "reg_names", "[", "<NUM_LIT>", "]", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "B", ";", "bits", "<", "<NUM_LIT>", ">", "A", ";", "bits", "<", "<NUM_LIT>", ">", "C", ";", "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "A", ";" ]

[ "bool", "free_insn_info", "(", "const", "rtx", "&", "t", "ATTRIBUTE_UNUSED", ",", "insn_info_list_t", "*", "v", ",", "void", "*", "arg", "ATTRIBUTE_UNUSED", ")", "{", "while", "(", "v", "->", "length", "(", ")", ">", "<NUM_LIT>", ")", "delete", "v", "->", "pop", "(", ")", ";", "return", "true", ";", "}" ]

[ "Callback", "to", "free", "all", "tag_insn_info", "objects", "." ]

[ ")", ";" ]

[ "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "OrigArg", ".", "Ty", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "SplitVTs", "[", "<NUM_LIT>", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "unsigned", "FirstRegIdx", "=", "SplitArgs", ".", "size", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "SplitVT", "=", "SplitVTs", "[", "i", "]", ";", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "auto", "Flags", "=", "OrigArg", ".", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "SplitTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment" ]

[ "m512", "_", "_", "B", ",", "_", "_", "m512", "_", "_", "C", ",", "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_fmaddsub_round_ps", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "A", ",", "_", "_" ]

[ "}" ]

[ "bool", "isSCSrc32", "(", ")", "const", "{", "return", "isInlineImm", "(", ")", "||", "(", "isReg", "(", ")", "&&", "isRegClass", "(", "AMDGPU", "::", "SReg_32RegClassID", ")", ")", ";" ]

[ ".", "Unsigned", ",", "top", ">", ";" ]

[ "def", "<STR_LIT>", ":", "MVE_VMOVL", "<", "<STR_LIT>", "#", "chr", ",", "InVTI", ".", "Suffix", ",", "OutVTI", ".", "Size", ",", "InVTI" ]

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

[ "(", "and", "(" ]

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

[ "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "mf", ".", "getSubtarget", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "constant island machine function ", "<STR_LIT>", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "STI", "->", "inMips16Mode", "(", ")", "||", "!", "MipsSubtarget", "::", "useConstantIslands", "(", ")", ")", "{", "return", "false", ";", "}", "TII", "=", "(", "const", "Mips16InstrInfo", "*", ")", "STI", "->", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "constant island processing ", "<STR_LIT>", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "PrescannedForConstants", ")", "prescanForConstants", "(", ")", ";", "HasFarJump", "=", "false", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "<NUM_LIT>", ",", "NoBRIters", "=", "<NUM_LIT>", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Beginning CP iteration #", "<STR_LIT>", "<<", "NoCPIters", "<<", "'", "\\n", "'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Constant Island pass failed to converge!" ]

[ "}" ]

[ "ComplexPattern", "Wpat", "=", "windex", ";", "ComplexPattern", "Xpat", "=", "xindex", ";", "Operand", "Wext", "=", "wextend", ";", "Operand", "Xext", "=", "xextend", ";" ]

[ "<FIXS>", "epilogue_size_needed", "=", "MAX", "(", "size_needed", "-", "<NUM_LIT>", ",", "desired_align", "-", "align", ")", ";", "epilogue_size_needed", "=", "smallest_pow2_greater_than", "(", "epilogue_size_needed", ")", ";", "<FIXE>", "<FIXS>", "GEN_INT", "(", "epilogue_size_needed", ")", ",", "LTU", ",", "<NUM_LIT>", ",", "GET_MODE", "(", "count_exp", ")", ",", "<NUM_LIT>", ",", "label", ")", ";", "if", "(", "expected_size", "==", "-", "<NUM_LIT>", "||", "expected_size", "epilogue_size_needed", ")", "<FIXE>" ]

[ "count_exp", "=", "force_reg", "(", "mode", ",", "count_exp", ")", ";", "}", "gcc_assert", "(", "desired_align", ">=", "<NUM_LIT>", "&&", "align", ">=", "<NUM_LIT>", ")", ";", "if", "(", "(", "size_needed", ">", "<NUM_LIT>", "||", "(", "desired_align", ">", "<NUM_LIT>", "&&", "desired_align", ">", "align", ")", ")", "&&", "!", "count", ")", "{", "<BUGS>", "int", "size", "=", "MAX", "(", "size_needed", "-", "<NUM_LIT>", ",", "desired_align", "-", "align", ")", ";", "<BUGE>", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "count_exp", ",", "<BUGS>", "GEN_INT", "(", "size", ")", ",", "LEU", ",", "<NUM_LIT>", ",", "GET_MODE", "(", "count_exp", ")", ",", "<NUM_LIT>", ",", "label", ")", ";", "if", "(", "expected_size", "==", "-", "<NUM_LIT>", "||", "expected_size", "size", ")", "<BUGE>", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ")", ";", "elsepredict_jump", "(", "REG_BR_PROB_BASE", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ")", ";" ]

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

[ "class", "BaseSIMDTableLookup", "<", "bit", "Q", ",", "bits", "<", "<NUM_LIT>", ">", "len", ",", "bit", "op", ",", "RegisterOperand", "vectype", ",", "RegisterOperand", "listtype", ",", "string", "asm", ",", "string", "kind", ">", ":", "I", "<", "(", "outs", "vectype", ":", "$", "Vd", ")", ",", "(", "ins", "listtype", ":", "$", "Vn", ",", "vectype", ":", "$", "Vm", ")", ",", "asm", ",", "<STR_LIT>", "#", "kind", "#", "<STR_LIT>", "#", "kind", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "!", "if", "(", "Q", ",", "WriteVq", ",", "WriteVd", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Vd", ";", "bits", "<", "<NUM_LIT>", ">", "Vn", ";", "bits", "<", "<NUM_LIT>", ">", "Vm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vm", ";" ]

[ "}" ]

[ "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";" ]

[ "UNSPEC_FMADDSUB", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VF_AVX512VL", "(", "unspec", ":", "VF_AVX512VL", "[", "(", "match_operand", ":", "VF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "VF_AVX512VL", "(", "match_operand", ":", "VF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "{" ]

[ "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "<NUM_LIT>", ";", "MachineBasicBlock", "::", "iterator", "AfterPop", "=", "MBBI", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "<NUM_LIT>", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "unsigned", "DwarfStackPtr", "=", "TRI", "->", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "cfiDefCfa", "(", "nullptr", ",", "DwarfStackPtr", ",", "<NUM_LIT>", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "--", "MBBI", ";", "if", "(", "!", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "MBB", ".", "isReturnBlock", "(", ")", ")", "{", "unsigned", "DwarfFramePtr", "=", "TRI", "->", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "BuildCFI", "(", "MBB", ",", "AfterPop", ",", "DL", ",", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "DwarfFramePtr", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "--", "MBBI", ";", "--", "AfterPop", ";", "}", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "MachineBasicBlock", "::", "iterator", "FirstCSPop", "=", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "!", "PI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "FirstCSPop", "=", "PI", ";", "--", "MBBI", ";", "}", "MBBI", "=", "FirstCSPop", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "CSSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "NumBytes", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "cfiDefCfaOffset", "(", "nullptr", ",", "CSSize", "+", "<NUM_LIT>", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "}", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "MBBI", "=", "FirstCSPop", ";", "int64_t", "Offset", "=", "-", "CSSize", "-", "<NUM_LIT>", ";" ]

[ "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_LOAD_GOT", ")", ")" ]

[ "(", "unspec", ":", "P", "[", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_LOADGP", ")", ")", "]", "<STR_LIT>", "{", "return", "mips_must_initialize_gp_p", "(", ")", "?", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "high", ":", "P", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "P", "[", "(", "match_dup", "<NUM_LIT>", ")" ]

[ ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "(", "set", "cls", ":", "$", "R1", ",", "(", "operator", "cls", ":", "$", "R1src", ",", "shift12only", ":", "$", "BD2", ")", ")", "]", ">", "{" ]

[ "class", "BinaryRS", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "SDPatternOperator", "operator", ",", "RegisterOperand", "cls", ">", ":", "InstRSa", "<", "opcode", ",", "(", "outs", "cls", ":", "$", "R1", ")", ",", "(", "ins", "cls", ":", "$", "R1src", ",", "shift12only", ":", "$", "BD2", ")" ]

[ "}" ]

[ "SDValue", "Vec", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getConstant", "(", "Vec", ".", "getScalarValueSizeInBits", "(", ")", "-", "<NUM_LIT>", ",", "DL", ",", "ResTy", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "ResTy", ",", "Vec", ",", "Mask", ")", ";" ]

[ "}" ]

[ "if", "(", "blocks", "[", "i", "]", "->", "getMBB", "(", ")", "==", "MBB", ")", "{", "return", "!", "Priv", "->", "LRs", ".", "at", "(", "pred", ")", ".", "hasDefBefore", "(", "i", ")", ";", "}" ]

[ "<STR_LIT>", ")" ]

[ "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "WebAssembly", "::", "parseMVT", "(", "VT", ".", "Value", ")", ")", ";" ]

[ "for", "(", "auto", "VT", ":", "YamlMFI", ".", "Params", ")", "addParam", "(", "WebAssembly", "::", "parseMVT", "(", "VT", ".", "Value", ")", ")", ";", "for", "(", "auto", "VT", ":", "YamlMFI", ".", "Results", ")", "addResult", "(" ]

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

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

[ "void", "TGSIFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "mf", ",", "MachineBasicBlock", "&", "mbb", ")", "const", "{", "MachineFrameInfo", "&", "mfi", "=", "mf", ".", "getFrameInfo", "(", ")", ";", "const", "TGSIInstrInfo", "&", "tii", "=", "*", "static_cast", "<", "const", "TGSIInstrInfo", "*", ">", "(", "mf", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "mbbi", "=", "mbb", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "int", "frame_sz", "=", "mfi", ".", "getStackSize", "(", ")", ";", "if", "(", "frame_sz", "==", "<NUM_LIT>", ")", "return", ";", "BuildMI", "(", "mbb", ",", "mbbi", ",", "dl", ",", "tii", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "frame_sz", ")", ";", "}" ]

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

[ "_", "v4si", ")", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_cvtdq2pd256", "(", "(", "_" ]

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

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

[ "VT", ",", "Chain", ")", ";" ]

[ "Register", "Reg", "=", "MF", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "ReturnAddress", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "}", "SDNode", "*", "St", ";", "if", "(", "Subtarget", "->", "hasPAuth", "(", ")", ")", "{", "St", "=", "DAG", ".", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "ReturnAddress", ")", ";", "}", "else", "{", "SDValue", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "ReturnAddress", ")", ";", "St", "=", "DAG", ".", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", "," ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isIndirectBranch", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "static", "void", "s390_save_gprs_to_fprs", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "i", ")", ")", ")", "{", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "cfun_gpr_save_slot", "(", "i", ")", ")", ",", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "copy_rtx", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "}", "}", "}" ]

[ "Copy", "GPRS", "into", "FPR", "save", "slots", "." ]

[ "=", "LPadList", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{" ]

[ "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tLEApcrelJT", ")", ",", "NewVReg3", ")", ".", "addJumpTableIndex", "(", "MJTI", ")", ".", "addImm", "(", "UId", ")", ")", ";", "unsigned", "NewVReg4", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tADDrr", ")", ",", "NewVReg4", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "NewVReg2", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "NewVReg3", ")", ")", ";", "MachineMemOperand", "*", "JTMMOLd", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getJumpTable", "(", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "NewVReg5", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tLDRi", ")", ",", "NewVReg5", ")", ".", "addReg", "(", "NewVReg4", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "JTMMOLd", ")", ")", ";", "unsigned", "NewVReg6", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tADDrr", ")", ",", "NewVReg6", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "NewVReg5", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "NewVReg3", ")", ")", ";", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tBR_JTr", ")", ")", ".", "addReg", "(", "NewVReg6", ",", "RegState", "::", "Kill", ")", ".", "addJumpTableIndex", "(", "MJTI", ")", ".", "addImm", "(", "UId", ")", ";", "}", "else", "{", "unsigned", "NewVReg1", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LDRi12", ")", ",", "NewVReg1", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "FIMMOLd", ")", ")", ";", "if", "(", "NumLPads", "<", "<NUM_LIT>", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "CMPri", ")", ")", ".", "addReg", "(", "NewVReg1", ")", ".", "addImm", "(", "NumLPads", ")", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasV6T2Ops", "(", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "NumLPads", ")", ")", "{", "unsigned", "VReg1", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "MOVi16", ")", ",", "VReg1", ")", ".", "addImm", "(", "NumLPads", "&", "<NUM_LIT>", ")", ")", ";", "unsigned", "VReg2", "=", "VReg1", ";", "if", "(", "(", "NumLPads", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "VReg2", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "MOVTi16", ")", ",", "VReg2", ")", ".", "addReg", "(", "VReg1", ")", ".", "addImm", "(", "NumLPads", ">>", "<NUM_LIT>", ")", ")", ";", "}", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "CMPrr", ")", ")", ".", "addReg", "(", "NewVReg1", ")", ".", "addReg", "(", "VReg2", ")", ")", ";", "}", "else", "{", "MachineConstantPool", "*", "ConstantPool", "=", "MF", "->", "getConstantPool", "(", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "NumLPads", ")", ";", "unsigned", "Align", "=", "getDataLayout", "(", ")", "->", "getPrefTypeAlignment", "(", "Int32Ty", ")", ";", "if", "(", "Align", "==", "<NUM_LIT>", ")", "Align", "=", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "C", "->", "getType", "(", ")", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "Align", ")", ";", "unsigned", "VReg1", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "VReg1", ",", "RegState", "::", "Define", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "CMPrr", ")", ")", ".", "addReg", "(", "NewVReg1", ")", ".", "addReg", "(", "VReg1", ",", "RegState", "::", "Kill", ")", ")", ";", "}", "BuildMI", "(", "DispatchBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "Bcc", ")", ")", ".", "addMBB", "(", "TrapBB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ")", ";", "unsigned", "NewVReg3", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultCC", "(", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "MOVsi", ")", ",", "NewVReg3", ")", ".", "addReg", "(", "NewVReg1", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "unsigned", "NewVReg4", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LEApcrelJT", ")", ",", "NewVReg4", ")", ".", "addJumpTableIndex", "(", "MJTI", ")", ".", "addImm", "(", "UId", ")", ")", ";", "MachineMemOperand", "*", "JTMMOLd", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getJumpTable", "(", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "NewVReg5", "=", "MRI", "->", "createVirtualRegister", "(", "TRC", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LDRrs", ")", ",", "NewVReg5", ")", ".", "addReg", "(", "NewVReg3", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "NewVReg4", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "JTMMOLd", ")", ")", ";", "BuildMI", "(", "DispContBB", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "BR_JTadd", ")", ")", ".", "addReg", "(", "NewVReg5", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "NewVReg4", ")", ".", "addJumpTableIndex", "(", "MJTI", ")", ".", "addImm", "(", "UId", ")", ";", "}", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "<NUM_LIT>", ">", "SeenMBBs", ";", "for", "(", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "::", "iterator", "I", "=", "LPadList", ".", "begin", "(", ")", ",", "E" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_max_epu8", "(", "_", "_", "mmask32", "_", "_", "M", ",", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pmaxub256_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "A", ",", "(", "_", "_", "v32qi", ")", "_", "_", "B", ",", "(", "_", "_", "v32qi", ")", "_", "mm256_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask32", ")", "_", "_", "M", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

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

[ "def", "A2_vconj", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_cf8126ae", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "&&", "REGNO_POINTER_ALIGN", "(", "REGNO", "(", "parts", ".", "index", ")", ")", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "if", "(", "REGNO_POINTER_ALIGN", "(", "REGNO", "(", "parts", ".", "base", ")", ")", "<NUM_LIT>", ")", "<FIXE>" ]

[ "if", "(", "parts", ".", "index", ")", "{", "if", "(", "parts", ".", "scale", "<NUM_LIT>", "<BUGS>", "&&", "REGNO_POINTER_ALIGN", "(", "REGNO", "(", "parts", ".", "index", ")", ")", "<NUM_LIT>", ")", "<BUGE>", "return", "<NUM_LIT>", ";", "}", "if", "(", "parts", ".", "base", ")", "{", "<BUGS>", "if", "(", "REGNO_POINTER_ALIGN", "(", "REGNO", "(", "parts", ".", "base", ")", ")", "<NUM_LIT>", ")", "<BUGE>", "return", "<NUM_LIT>", ";", "}", "if", "(", "parts", ".", "disp", ")" ]

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

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>" ]

[ "a", ")", "{" ]

[ "vreinterpretq_u32_f16", "(", "float16x8_t", "_", "_" ]

[ "<STR_LIT>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]" ]

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

[ "class", "BaseFPCondSelect", "<", "RegisterClass", "regtype", ",", "ValueType", "vt", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "ccode", ":", "$", "cond", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "ARM64csel", "(", "vt", "regtype", ":", "$", "Rn", ")", ",", "regtype", ":", "$", "Rm", ",", "(", "i32", "imm", ":", "$", "cond", ")", ",", "CPSR", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteF", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ "let", "AsmVariantName", "=", "ps", ".", "AsmVariantName", ";" ]

[ "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "UseNamedOperandTable", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "ps", ".", "Constraints", ";", "let", "DisableEncoding", "=", "ps", ".", "DisableEncoding", ";", "let", "SubtargetPredicate", "=", "ps", ".", "SubtargetPredicate", ";", "let", "OtherPredicates", "=", "ps", ".", "OtherPredicates", ";", "let", "AsmMatchConverter", "=", "ps", ".", "AsmMatchConverter", ";" ]

[ "(", ")", ")", ",", "OpTy", ".", "getVectorNumElements", "(", ")", ")", ";" ]

[ "const", "SDLoc", "&", "dl", "(", "Op", ")", ";", "if", "(", "OpTy", "==", "MVT", "::", "v2i16", "||", "OpTy", "==", "MVT", "::", "v4i8", ")", "{", "MVT", "ElemTy", "=", "OpTy", ".", "getVectorElementType", "(", ")", ";", "assert", "(", "ElemTy", ".", "isScalarInteger", "(", ")", ")", ";", "MVT", "WideTy", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "getIntegerVT", "(", "<NUM_LIT>", "*", "ElemTy", ".", "getSizeInBits" ]

[ ")", ";" ]

[ "if", "(", "TheTriple", ".", "isOSDarwin", "(", ")", ")", "return", "new", "ARMMCAsmInfoDarwin", "(", ")", ";", "return", "new", "ARMELFMCAsmInfo", "(" ]

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

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

[ "}" ]

[ "case", "ISD", "::", "SETO", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUO", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETULE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", "{", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "isUnsigned", "=", "true", ";", "case", "ISD", "::", "SETLE", ":", "case", "ISD", "::", "SETOLE", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", "{", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "isUnsigned", "=", "true", ";", "case", "ISD", "::", "SETGE", ":", "case", "ISD", "::", "SETOGE", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGT", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", "{", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "isUnsigned", "=", "true", ";", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETOGT", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETULT", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", "{", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "isUnsigned", "=", "true", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETOLT", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";" ]

[ "_", "m128i", "_", "<NUM_LIT>", ",", "_", "_", "m128i", "_", "<NUM_LIT>", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m128i", "_", "_", "lsx_vmaddwev_q_du_d", "(", "_", "_", "m128i", "_", "<NUM_LIT>", ",", "_" ]

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

[ "void", "Cpu0MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "(", "Opcode", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "<STR_LIT>", "unimplemented opcode in encodeInstruction()", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "llvm_unreachable", "(", "<STR_LIT>", "Pseudo opcode found in encodeInstruction()", "<STR_LIT>", ")", ";", "int", "Size", "=", "<NUM_LIT>", ";", "EmitInstruction", "(", "Binary", ",", "Size" ]

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

[ "def", "INSELd", ":", "NeonI_INS_element", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "neon_uimm1_bare", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "{", "Immd", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";" ]