Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "let", "KeyCol", "=", "[", "<STR_LIT>", "]", ";", "let", "ValueCols", "=", "[", "[", "<STR_LIT>", "]", "]", ";" ]

[ "Data", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "LegalReqRetVT", ",", "Data", ")", ";" ]

[ "if", "(", "MaskPopVT", ".", "isVector", "(", ")", ")", "{", "Data", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "MaskPopVT", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ",", "ZeroIdx", ")", ";", "}", "else", "{", "Data", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "MaskPopVT", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ",", "ZeroIdx", ")", ";", "}", "}", "if", "(", "DataDwordVT", ".", "isVector", "(", ")", "&&", "!", "IsAtomicPacked16Bit", ")", "Data", "=", "padEltsToUndef", "(", "DAG", ",", "DL", ",", "DataDwordVT", ",", "Data", ",", "NumDataDwords", "-", "MaskPopDwords", ")", ";", "if", "(", "IsD16", ")", "Data", "=", "adjustLoadValueTypeImpl", "(", "Data", ",", "ReqRetVT", ",", "DL", ",", "DAG", ",", "Unpacked", ")", ";", "EVT", "LegalReqRetVT", "=", "ReqRetVT", ";", "if", "(", "!", "ReqRetVT", ".", "isVector", "(", ")", ")", "{", "if", "(", "!", "Data", ".", "getValueType", "(", ")", ".", "isInteger", "(", ")", ")", "Data", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "Data", ".", "getValueType", "(", ")", ".", "changeTypeToInteger", "(", ")", ",", "Data", ")", ";", "Data", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "ReqRetVT", ".", "changeTypeToInteger", "(", ")", ",", "Data", ")", ";", "}", "else", "{", "if", "(", "(", "ReqRetVT", ".", "getVectorNumElements", "(", ")", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "ReqRetVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "LegalReqRetVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "ReqRetVT", ".", "getVectorElementType", "(", ")", ",", "ReqRetVT", ".", "getVectorNumElements", "(", ")", "+", "<NUM_LIT>", ")", ";", "}", "}" ]

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

[ "bool", "SPIRVSubtarget", "::", "canDirectlyComparePointers", "(", ")", "const", "{", "return", "isAtLeastVer", "(", "SPIRVVersion" ]

[ ")" ]

[ "[", "(", "unspec_volatile", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CONSTTABLE", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

[ "(", "minus", "<STR_LIT>", ")", "(", "plus", "<STR_LIT>", ")", "(", "mult", "<STR_LIT>", ")", "(", "smin", "<STR_LIT>", ")", "(", "umin", "<STR_LIT>", ")", "(", "smax", "<STR_LIT>", ")" ]

[ ")", "]" ]

[ "(", "abs", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Pu", ";", "bits", "<", "<NUM_LIT>", ">", "s8", ";", "bits", "<", "<NUM_LIT>", ">", "S8", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pu", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "S8", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ":", "$", "src1", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", "#", "<STR_LIT>", ",", "(", "FCMGEv2f32", "V64", ":", "$", "dst", ",", "V64", ":", "$", "src2", ",", "V64" ]

[ "unsigned", "MOVOpc", "=", "Subtarget", ".", "hasAVX", "(", ")", "?", "X86", "::", "VMOVAPSmr", ":", "X86", "::", "MOVAPSmr", ";" ]

[ "MachineFunction", "*", "F", "=", "MBB", "->", "getParent", "(", ")", ";", "MachineFunction", "::", "iterator", "MBBIter", "=", "++", "MBB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "XMMSaveMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "EndMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "MBBIter", ",", "XMMSaveMBB", ")", ";", "F", "->", "insert", "(", "MBBIter", ",", "EndMBB", ")", ";", "EndMBB", "->", "splice", "(", "EndMBB", "->", "begin", "(", ")", ",", "MBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "MBB", "->", "end", "(", ")", ")", ";", "EndMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "MBB", ")", ";", "MBB", "->", "addSuccessor", "(", "XMMSaveMBB", ")", ";", "XMMSaveMBB", "->", "addSuccessor", "(", "EndMBB", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "Register", "CountReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int", "RegSaveFrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "int64_t", "VarArgsFPOffset", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isCallingConvWin64", "(", "F", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", ")", "{", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "TEST8rr", ")", ")", ".", "addReg", "(", "CountReg", ")", ".", "addReg", "(", "CountReg", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "EndMBB", ")", ".", "addImm", "(", "X86", "::", "COND_E", ")", ";", "MBB", "->", "addSuccessor", "(", "EndMBB", ")", ";", "}", "assert", "(", "(", "MI", ".", "getNumOperands", "(", ")", "<=", "<NUM_LIT>", "||", "!", "MI", ".", "getOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "||", "MI", ".", "getOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "&&", "<STR_LIT>", "Expected last argument to be EFLAGS", "<STR_LIT>", ")", ";" ]

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

[ "static", "void", "arm_set_fixed_conv_libfunc", "(", "convert_optab", "optable", ",", "machine_mode", "to", ",", "machine_mode", "from", ",", "const", "char", "*", "funcname", ",", "const", "char", "*", "toname", ",", "const", "char", "*", "fromname", ")", "{", "char", "buffer", "[", "<NUM_LIT>", "]", ";", "const", "char", "*", "maybe_suffix_2", "=", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "from", ")", "&&", "ALL_FIXED_POINT_MODE_P", "(", "to", ")", "&&", "UNSIGNED_FIXED_POINT_MODE_P", "(", "from", ")", "==", "UNSIGNED_FIXED_POINT_MODE_P", "(", "to", ")", "&&", "ALL_FRACT_MODE_P", "(", "from", ")", "==", "ALL_FRACT_MODE_P", "(", "to", ")", ")", "maybe_suffix_2", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "sprintf", "(", "buffer", ",", "<STR_LIT>", "__gnu_%s%s%s%s", "<STR_LIT>", ",", "funcname", ",", "fromname", ",", "toname", ",", "maybe_suffix_2", ")", ";", "set_conv_libfunc", "(", "optable", ",", "to", ",", "from", "," ]

[ "<NUM_LIT>", ";" ]

[ "class", "StoreInst_GEN_ADDR", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "bit", "TnsrReg", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "StoreInstGenericSrcB", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "ADRF", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "i8imm", ":", "$", "tensor", ",", "IRF", ":", "$", "coords", ",", "SwitchSet", ":", "$", "sw", ",", "ADRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_StoreComplexOp", ";", "let", "isNotUsedInDisasm", "=" ]

[ "}" ]

[ "void", "NMXSEInstrInfo", "::", "expandRetLR", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NMX", "::", "RET", ")", ")", ".", "addReg", "(", "NMX", "::", "LR", ")", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "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>" ]

[ ";" ]

[ "void", "arm_pr_no_long_calls", "(", "struct", "cpp_reader", "*", "pfile", "ATTRIBUTE_UNUSED", ")", "{", "arm_pragma_long_calls", "=", "SHORT" ]

[ "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isNullConstant", "(", "LHS", ")", "&&", "isNullConstant", "(", "RHS", ")", ")", "{", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "return", ";", "}", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "if", "(", "Known", ".", "isUnknown", "(", ")", ")", "return", ";", "KnownBits", "KnownRHS", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "Known", ".", "Zero", "&=", "KnownRHS", ".", "Zero", ";", "Known", ".", "One", "&=", "KnownRHS", ".", "One", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "Known", ".", "Zero", "&=", "Mask", ";", "Known", ".", "One", "&=", "Mask", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "const", "SDValue", "&", "SrcSV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VecVT", "=", "SrcSV", ".", "getValueType", "(", ")", ";", "assert", "(", "VecVT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "VGETLANE expected a vector type", "<STR_LIT>", ")", ";", "const", "unsigned", "NumSrcElts", "=", "VecVT", ".", "getVectorNumElements", "(", ")", ";", "ConstantSDNode", "*", "Pos", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ";", "assert", "(", "Pos", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "NumSrcElts", ")", "&&", "<STR_LIT>", "VGETLANE index out of bounds", "<STR_LIT>", ")", ";", "unsigned", "Idx", "=", "Pos", "->", "getZExtValue", "(", ")", ";", "APInt", "DemandedElt", "=", "APInt", "::", "getOneBitSet", "(", "NumSrcElts", ",", "Idx", ")", ";", "Known", "=", "DAG", ".", "computeKnownBits", "(", "SrcSV", ",", "DemandedElt", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "const", "unsigned", "DstSz", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "const", "unsigned", "SrcSz", "=", "VecVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "(", "void", ")", "SrcSz", ";", "assert", "(", "SrcSz", "==", "Known", ".", "getBitWidth", "(", ")", ")", ";", "assert", "(", "DstSz", ">", "SrcSz", ")", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Known", "=", "Known", ".", "sext", "(", "DstSz", ")", ";", "else", "{", "Known", "=", "Known", ".", "zext", "(", "DstSz", ")", ";", "}", "assert", "(", "DstSz", "==", "Known", ".", "getBitWidth", "(", ")", ")", ";", "break", ";", "}", "}", "}" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

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

[ "(", "ior", ":", "ALL", "(", "not", ":", "ALL", "(", "match_operand", ":" ]

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

[ "return", "_", "_", "builtin_arm_qsub8", "(", "_", "_", "a", ",", "_" ]

[ ",", "?", ",", "?", "}", ",", "<STR_LIT>", ">", ";" ]

[ "def", "VLD4d16", ":", "VLD4D", "<", "<NUM_LIT>", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ ")", ";" ]

[ "return", "(", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "<FIXS>", "void", "initializeAMDGPUDAGToDAGISelLegacyPass", "(", "PassRegistry", "&", ")", ";", "<FIXE>" ]

[ "PreservedAnalyses", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", ";", "}", ";", "<BUGS>", "void", "initializeAMDGPUDAGToDAGISelPass", "(", "PassRegistry", "&", ")", ";", "<BUGE>", "void", "initializeAMDGPUMachineCFGStructurizerPass", "(", "PassRegistry", "&", ")", ";", "extern", "char", "&", "AMDGPUMachineCFGStructurizerID", ";" ]

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

[ "def", "C2_cmoveit", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_cda00a", ",", "PredNewRel", ",", "ImmRegRel", "{", "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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

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

[ "class", "MVE_VMOV_lane", "<", "string", "suffix", ",", "bit", "U", ",", "dag", "indexop", ",", "MVE_VMOV_lane_direction", "dir", ">", ":", "MVE_VMOV_lane_base", "<", "dir", ".", "oops", ",", "!", "con", "(", "dir", ".", "iops", ",", "indexop", ")", ",", "NoItinerary", ",", "<STR_LIT>", ",", "suffix", ",", "dir", ".", "ops", ",", "dir", ".", "cstr", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Qd", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "dir", ".", "bit_20", ";" ]

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

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

[ "static", "void", "rs6000_output_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "macho_branch_islands", "(", ")", ";", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx_insn", "*", "delete", "d_debug_label", "=", "NULL", ";", "while", "(", "insn", "&&", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "!=", "NOTE_INSN_DELETED_LABEL", ")", "{", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_DELETED_DEBUG_LABEL", ")", "delete", "d_debug_label", "=", "insn", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "}", "if", "(", "insn", "&&", "(", "LABEL_P", "(", "insn", ")", "||", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_DELETED_LABEL", ")", ")", ")", "fputs", "(", "<STR_LIT>", "\\tnop\\n", "<STR_LIT>", ",", "file", ")", ";", "else", "if", "(", "delete", "d_debug_label", ")", "for", "(", "insn", "=", "delete", "d_debug_label", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_DELETED_DEBUG_LABEL", ")", "CODE_LABEL_NUMBER", "(", "insn", ")", "=", "-", "<NUM_LIT>", ";", "}", "if", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "!", "flag_inhibit_size_directive", "&&", "rs6000_traceback", "!=", "traceback_none", "&&", "!", "cfun", "->", "is_thunk", ")", "{", "const", "char", "*", "fname", "=", "NULL", ";", "const", "char", "*", "language_string", "=", "lang_hooks", ".", "name", ";", "int", "fixed_parms", "=", "<NUM_LIT>", ",", "float_parms", "=", "<NUM_LIT>", ",", "parm_info", "=", "<NUM_LIT>", ";", "int", "i", ";", "int", "optional_tbtab", ";", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "rs6000_traceback", "==", "traceback_full", ")", "optional_tbtab", "=", "<NUM_LIT>", ";", "else", "if", "(", "rs6000_traceback", "==", "traceback_part", ")", "optional_tbtab", "=", "<NUM_LIT>", ";", "else", "optional_tbtab", "=", "!", "optimize_size", "&&", "!", "TARGET_ELF", ";", "if", "(", "optional_tbtab", ")", "{", "fname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "while", "(", "*", "fname", "==", "'", ".", "'", ")", "fname", "++", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "file", ",", "<STR_LIT>", "LT", "<STR_LIT>", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "fname", ")", ";", "}", "fputs", "(", "<STR_LIT>", "\\t.long 0\\n", "<STR_LIT>", ",", "file", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.byte 0,", "<STR_LIT>", ",", "file", ")", ";", "if", "(", "lang_GNU_C", "(", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU GIMPLE", "<STR_LIT>", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Go", "<STR_LIT>", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "libgccjit", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU F77", "<STR_LIT>", ")", "||", "lang_GNU_Fortran", "(", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Pascal", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Ada", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "lang_GNU_CXX", "(", ")", "||", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Objective-C++", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Java", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "strcmp", "(", "language_string", ",", "<STR_LIT>", "GNU Objective-C", "<STR_LIT>", ")", ")", "i", "=", "<NUM_LIT>", ";", "else", "gcc_unreachable", "(", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "i", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "optional_tbtab", "<<", "<NUM_LIT>", ")", "|", "(", "(", "info", "->", "first_fp_reg_save", "!=", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "(", "optional_tbtab", "<<", "<NUM_LIT>", ")", "|", "(", "(", "optional_tbtab", "&", "frame_pointer_needed", ")", "<<", "<NUM_LIT>", ")", "|", "(", "info", "->", "cr_save_p", "<<", "<NUM_LIT>", ")", "|", "(", "info", "->", "lr_save_p", ")", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "info", "->", "push_p", "<<", "<NUM_LIT>", ")", "|", "(", "<NUM_LIT>", "-", "info", "->", "first_fp_reg_save", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "(", "<NUM_LIT>", "-", "first_reg_to_save", "(", ")", ")", ")", ";", "if", "(", "optional_tbtab", ")", "{", "tree", "decl", ";", "int", "next_parm_info_bit", "=", "<NUM_LIT>", ";", "for", "(", "decl", "=", "DECL_ARGUMENTS", "(", "current_function_decl", ")", ";", "decl", ";", "decl", "=", "DECL_CHAIN", "(", "decl", ")", ")", "{", "rtx", "parameter", "=", "DECL_INCOMING_RTL", "(", "decl", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "parameter", ")", ";", "if", "(", "GET_CODE", "(", "parameter", ")", "==", "REG", ")", "{", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "int", "bits", ";", "float_parms", "++", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "SDmode", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "DFmode", ":", "case", "DDmode", ":", "case", "TFmode", ":", "case", "TDmode", ":", "case", "IFmode", ":", "case", "KFmode", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "next_parm_info_bit", ">", "<NUM_LIT>", ")", "parm_info", "|=", "(", "bits", "<<", "(", "next_parm_info_bit", "-", "<NUM_LIT>", ")", ")", ";", "next_parm_info_bit", "-=", "<NUM_LIT>", ";", "}", "else", "{", "fixed_parms", "+=", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "(", "UNITS_PER_WORD", "-", "<NUM_LIT>", ")", ")", "/", "UNITS_PER_WORD", ")", ";", "next_parm_info_bit", "-=", "<NUM_LIT>", ";", "}", "}", "}", "}", "fprintf", "(", "file", ",", "<STR_LIT>", "%d,", "<STR_LIT>", ",", "fixed_parms", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%d\\n", "<STR_LIT>", ",", "(", "(", "float_parms", "<<", "<NUM_LIT>", ")", "|", "(", "!", "optimize", ")", ")", ")", ";", "if", "(", "!", "optional_tbtab", ")", "return", ";", "if", "(", "fixed_parms", "||", "float_parms", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.long %d\\n", "<STR_LIT>", ",", "parm_info", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.long ", "<STR_LIT>", ",", "file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "file", ",", "<STR_LIT>", "LT", "<STR_LIT>", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "fname", ")", ";", "putc", "(", "'", "-", "'", ",", "file", ")", ";", "rs6000_output_function_entry", "(", "file", ",", "fname", ")", ";", "putc", "(", "'", "\\n", "'", ",", "file", ")", ";", "if", "(", "*", "fname", "==", "'", "*", "'", ")", "++", "fname", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.short %d\\n", "<STR_LIT>", ",", "(", "int", ")", "strlen", "(", "fname", ")", ")", ";", "assemble_string", "(", "fname", ",", "strlen", "(", "fname", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "fputs", "(", "<STR_LIT>", "\\t.byte 31\\n", "<STR_LIT>", ",", "file", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.align 2\\n", "<STR_LIT>", ",", "file", ")", ";", "}", "if", "(", "need_toc_init", ")", "{", "need_toc_init", "=", "<NUM_LIT>", ";", "if", "(", "!", "toc_initialized", ")", "{", "switch_to_section", "(", "toc_section", ")", ";", "switch_to_section", "(", "current_function_section", "(", ")", ")", ";", "}", "}", "}" ]

[ "Write", "function", "epilogue", "." ]

[ "USR_OVF", "]", ";" ]

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

[ ";" ]

[ "static", "DecodeStatus", "DecodeBranchTarget26MM", "(", "MCInst", "&", "Inst", ",", "unsigned", "Offset", ",", "uint64_t", "Address", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "int32_t", "BranchOffset", "=", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "Offset", "<<", "<NUM_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "BranchOffset", ")", ")", ";", "return", "MCDisassembler", "::", "Success" ]

[ "}" ]

[ "void", "xstormy16_function_profiler", "(", "void", ")", "{", "sorry", "(", "<STR_LIT>", "%<function_profiler%> support", "<STR_LIT>", ")", ";" ]

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

[ "class", "BaseAddSubImm", "<", "bit", "isSub", ",", "bit", "setFlags", ",", "RegisterClass", "dstRegtype", ",", "string", "asm_inst", ",", "string", "asm_ops", ",", "dag", "inputs", ",", "dag", "pattern", ">", ":", "I", "<", "(", "outs", "dstRegtype", ":", "$", "Rd", ")", ",", "inputs", ",", "asm_inst", ",", "asm_ops", ",", "<STR_LIT>", ",", "[", "pattern", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "return", "isInt", "<", "<NUM_LIT>", ">", "(", "v", ")", ";" ]

[ "static", "bool", "IsS11_0_Offset", "(", "SDNode", "*", "S", ")", "{", "ConstantSDNode", "*", "N", "=", "cast", "<", "ConstantSDNode", ">", "(", "S", ")", ";", "int64_t", "v", "=", "(", "int64_t", ")", "N", "->", "getSExtValue", "(", ")", ";" ]

[ "<FIXS>", "return", "selectVSplat", "(", "N", ",", "Imm", ",", "EltTy", ".", "getSizeInBits", "(", ")", ")", "&", "&", "<FIXE>" ]

[ "APInt", "Imm", ";", "EVT", "EltTy", "=", "N", "-", ">", "getValueType", "(", "<NUM_LIT>", ")", ".", "getVectorElementType", "(", ")", ";", "<BUGS>", "return", "selectVSplat", "(", "N", ",", "Imm", ")", "&", "&", "<BUGE>", "Imm", ".", "getBitWidth", "(", ")", "=", "=", "EltTy", ".", "getSizeInBits", "(", ")", "&", "&", "Imm", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", ";" ]

[ "Rv", "(", "StackFixup", "::", "xc2pu", "(", "i", ",", "j", ",", "k", ")", ")", ";" ]

[ "XchgPairCorrector", "CorrectI", "(", "i", ",", "<NUM_LIT>", ")", ";", "CorrectI", "(", "j", ")", "(", "k", ")", ";", "XchgPairCorrector", "CorrectJ", "(", "j", ",", "<NUM_LIT>", ")", ";", "CorrectJ", "(", "k", ")", ";" ]

[ "}" ]

[ "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Custom lowering code for this", "<STR_LIT>", "<STR_LIT>", "instruction is not implemented yet!", "<STR_LIT>", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SREM", ":", "return", "LowerSREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "DoubleWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=" ]

[ "unsigned", "ARMBaseRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "case", "ARM", "::", "GPRRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "<NUM_LIT>", "-", "FP", "-", "(", "STI", ".", "isR9Reserved", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "}", "}" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "<NUM_LIT>", "==", "(", "pop_mask", "&", "(", "<NUM_LIT>", "<<", "popcount_hwi", "(", "val8", ")", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "." ]

[ "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "<STR_LIT>", "hi12", "<STR_LIT>", ",", "O", ")", ";" ]

[ "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "'", "#", "'", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "assert", "(", "MO", ".", "getFPImm", "(", ")", "->", "isExactlyValue", "(", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Only FP 0.0 expected", "<STR_LIT>", ")", ";", "O", "<<", "<STR_LIT>", "#0.0", "<STR_LIT>", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "return", "printSymbolicAddress", "(", "MO", ",", "false", ",", "<STR_LIT>", "<STR_LIT>", ",", "O", ")", ";", "}", "return", "false", ";", "}", "switch", "(", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'", "c", "'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "O", "<<", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'", "w", "'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "O", ")", ";", "case", "'", "x", "'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "O", ")", ";", "case", "'", "H", "'", ":", "case", "'", "Q", "'", ":", "case", "'", "R", "'", ":", "llvm_unreachable", "(", "<STR_LIT>", "FIXME: Unimplemented register pairs", "<STR_LIT>", ")", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "s", "'", ":", "case", "'", "d", "'", ":", "case", "'", "q", "'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "ExtraCode", "[", "<NUM_LIT>", "]", ",", "O", ")", ";", "case", "'", "A", "'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "false", ",", "<STR_LIT>", "<STR_LIT>", ",", "O", ")", ";", "case", "'", "L", "'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "<STR_LIT>", "lo12", "<STR_LIT>", ",", "O", ")", ";", "case", "'", "G", "'", ":" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "OffVal", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", ";", "NumBits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "OffVal", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", ";", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "OffVal", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "OffVal", ")", ";", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "NumBits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported addressing mode!", "<STR_LIT>", ")", ";", "}", "if", "(", "(", "(", "OffVal", "*", "Scale", "+", "Fixup", ")", "&", "(", "Scale", "-", "<NUM_LIT>", ")", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "OffVal", "+=", "Fixup", "/", "Scale", ";", "unsigned", "Mask", "=", "(", "<NUM_LIT>", "<<", "NumBits", ")", "-", "<NUM_LIT>", ";", "if", "(", "OffVal", "<=", "Mask", ")", "{", "if", "(", "Updt", ")", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "setImm", "(", "OffVal", ")", ";", "return", "true", ";" ]

[ "SYMBOL_REF_FLAGS", "(", "local", ")", "=", "SYMBOL_REF_FLAGS", "(", "func", ")", "|", "SYMBOL_FLAG_LOCAL", ";" ]

[ "gcc_assert", "(", "slot", "!=", "NULL", ")", ";", "if", "(", "!", "existed", ")", "{", "rtx", "local", ";", "func_name", "=", "targetm", ".", "strip_name_encoding", "(", "XSTR", "(", "func", ",", "<NUM_LIT>", ")", ")", ";", "const", "char", "*", "local_name", "=", "ACONCAT", "(", "(", "<STR_LIT>", "__fn_local_", "<STR_LIT>", ",", "func_name", ",", "NULL", ")", ")", ";", "local", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "local_name", ")", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "Cn", ";", "bits", "<", "<NUM_LIT>", ">", "Cm", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cm", ";" ]

[ "const", "{" ]

[ "bool", "hasScalarPackInsts", "(", ")" ]

[ "return", "false", ";" ]

[ "bool", "MipsDAGToDAGISel", "::", "selectVSplatUimm8", "(", "SDValue", "N", ",", "SDValue", "&", "Imm", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented function.", "<STR_LIT>", ")", ";" ]

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

[ "unsigned", "NSlots", ";", "if", "(", "MCID", "&&", "mustComeFirst", "(", "MCID", ",", "NSlots", ")", "&&", "CurSlots", ")", "return", "true", ";", "return", "ScoreboardHazardRecognizer", "::", "ShouldPreferAnother", "(" ]

[ "TheTriple", ",", "StringRef", "CPU", ",", "const", "MCTargetOptions", "&", "Options", ")", "{" ]

[ "MCAsmBackend", "*", "llvm", "::", "createZ80AsmBackend", "(", "const", "Target", "&", "T", ",", "const", "MCRegisterInfo", "&", "MRI", ",", "const", "Triple", "&" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "def", "LDgotTprelL", ":", "PPCEmitTimePseudo", "(", "outs", "g8rc_nox0", ":", "$", "rD", ")", ",", "(", "ins", "s16imm64", ":", "$", "disp", ",", "g8rc_nox0", ":", "$", "reg", ")", ",", "<FIXE>" ]

[ "(", "PPCaddisGotTprelHA", "i64", ":", "$", "reg", ",", "tglobaltlsaddr", ":", "$", "disp", ")", ")", "]", ">", ",", "isPPC64", ";", "<BUGS>", "def", "LDgotTprelL", ":", "PPCEmitTimePseudo", "(", "outs", "g8rc", ":", "$", "rD", ")", ",", "(", "ins", "s16imm64", ":", "$", "disp", ",", "g8rc_nox0", ":", "$", "reg", ")", ",", "<BUGE>", "<STR_LIT>", ",", "[", "(", "set", "i64", ":", "$", "rD", ",", "(", "PPCldGotTprelL", "tglobaltlsaddr", ":", "$", "disp", ",", "i64", ":", "$", "reg", ")", ")", "]", ">", "," ]

[ ";" ]

[ "}", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "(", "Mips", "::", "CondCode", ")", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "get", "(", "Opc", ")", ";", "if", "(", "TID", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "TID", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "TID", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "Mips", "::", "J", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "<NUM_LIT>" ]

[ "if", "(", "StOp", ".", "isReg", "(", ")", "&&", "StOp", ".", "getReg", "(", ")", "==", "TfrDefR", ")", "return", "false", ";" ]

[ "bool", "HexagonOptAddrMode", "::", "hasRepForm", "(", "MachineInstr", "&", "MI", ",", "unsigned", "TfrDefR", ")", "{", "const", "MCInstrDesc", "&", "MID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "(", "!", "MID", ".", "mayStore", "(", ")", "&&", "!", "MID", ".", "mayLoad", "(", ")", ")", "||", "HII", "->", "isPredicated", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "MID", ".", "mayStore", "(", ")", ")", "{", "MachineOperand", "StOp", "=", "MI", ".", "getOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";" ]

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

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

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

[ "def", "L2_loadrub_pi", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_222336", ",", "PredNewRel", ",", "PostInc_BaseImm", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

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

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SUNPKHI", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UZP2", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TRN1", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TRN2", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::REV16", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::REV32", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::REV64", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::EXT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::VSHL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::VLSHR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::VASHR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMEQ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGE", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMHI", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMHS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMEQ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGE", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMEQz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMLEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMLTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMEQz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMLEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMLTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SADDV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UADDV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SMINV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UMINV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SMAXV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UMAXV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::NOT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::BIT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CBZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CBNZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TBZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TBNZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TC_RETURN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::PREFETCH", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SITOF", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UITOF", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::NVCAST", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SQSHL_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UQSHL_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SRSHR_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::URSHR_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SQSHLU_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::WrapperLarge", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1DUPpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD2DUPpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD3DUPpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD4DUPpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD2LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD3LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD4LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST2LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST3LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST4LANEpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SMULL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UMULL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FRECPE", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FRECPS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FRSQRTE", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FRSQRTS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::STG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::STZG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST2G", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::STZ2G", "<STR_LIT>", ";" ]

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

[ "bool", "HexagonNoExtendOperand", "::", "evaluateAsRelocatableImpl", "(", "MCValue", "&", "Res", ",", "MCAsmLayout", "const", "*", "Layout", ",", "MCFixup", "const", "*", "Fixup", ")", "const", "{", "return", "Expr", "->", "evaluateAsRelocatable", "(", "Res", ",", "Layout" ]

[ "if", "(", "(", "BW", "<", "<NUM_LIT>", ")", "&&", "!", "IsBitTest", ")", "SrcReg", "=", "emitIntExt", "(", "VT", ",", "SrcReg", ",", "MVT", "::", "i32", ",", "true", ")", ";" ]

[ "case", "CmpInst", "::", "ICMP_SLT", ":", "case", "CmpInst", "::", "ICMP_SGE", ":", "if", "(", "!", "isa", "<", "Constant", ">", "(", "RHS", ")", "||", "!", "cast", "<", "Constant", ">", "(", "RHS", ")", "->", "isNullValue", "(", ")", ")", "return", "false", ";", "TestBit", "=", "BW", "-", "<NUM_LIT>", ";", "IsCmpNE", "=", "Predicate", "==", "CmpInst", "::", "ICMP_SLT", ";", "break", ";", "case", "CmpInst", "::", "ICMP_SGT", ":", "case", "CmpInst", "::", "ICMP_SLE", ":", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "RHS", ")", ")", "return", "false", ";", "if", "(", "cast", "<", "ConstantInt", ">", "(", "RHS", ")", "->", "getValue", "(", ")", "!=", "APInt", "(", "BW", ",", "-", "<NUM_LIT>", ",", "true", ")", ")", "return", "false", ";", "TestBit", "=", "BW", "-", "<NUM_LIT>", ";", "IsCmpNE", "=", "Predicate", "==", "CmpInst", "::", "ICMP_SLE", ";", "break", ";", "}", "static", "const", "unsigned", "OpcTable", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ";", "bool", "IsBitTest", "=", "TestBit", "!=", "-", "<NUM_LIT>", ";", "bool", "Is64Bit", "=", "BW", "==", "<NUM_LIT>", ";", "if", "(", "TestBit", "<", "<NUM_LIT>", "&&", "TestBit", ">=", "<NUM_LIT>", ")", "Is64Bit", "=", "false", ";", "unsigned", "Opc", "=", "OpcTable", "[", "IsBitTest", "]", "[", "IsCmpNE", "]", "[", "Is64Bit", "]", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "Opc", ")", ";", "unsigned", "SrcReg", "=", "getRegForValue", "(", "LHS", ")", ";", "if", "(", "!", "SrcReg", ")", "return", "false", ";", "if", "(", "BW", "==", "<NUM_LIT>", "&&", "!", "Is64Bit", ")", "SrcReg", "=", "fastEmitInst_extractsubreg", "(", "MVT", "::", "i32", ",", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", ")", "(", "set_attr", "<STR_LIT>" ]

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

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

[ "bool", "ValidLDType", "=", "MemoryType", "==", "MVT", "::", "i8", "||", "MemoryType", "==", "MVT", "::", "i16", "||", "MemoryType", "==", "MVT", "::", "i32", "||", "MemoryType", "==", "MVT", "::", "i64", ";" ]

[ "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "!=", "MVT", "::", "v1i128", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Operand", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Operand", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "SDValue", "(", ")", ";", "auto", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "Operand", ")", ";", "EVT", "MemoryType", "=", "LD", "->", "getMemoryVT", "(", ")", ";" ]

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

[ "class", "LoadStore32RO", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ",", "dag", "ins", ",", "dag", "outs", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "ins", ",", "outs", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "VT", ",", "N", ")", ";" ]

[ "uint64_t", "X", "=", "CI", "->", "getZExtValue", "(", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "X", "*", "EltSize", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "Vec", ",", "Width", ",", "Offset", "}", ";", "ConstantSDNode", "*", "CW", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Width", ")", ";", "assert", "(", "CW", "&&", "<STR_LIT>", "Non constant width in LowerEXTRACT_VECTOR", "<STR_LIT>", ")", ";", "SDValue", "N", ";", "MVT", "SVT", "=", "VecVT", ".", "getSimpleVT", "(", ")", ";", "uint64_t", "W", "=", "CW", "->", "getZExtValue", "(", ")", ";", "if", "(", "W", "==", "<NUM_LIT>", ")", "{", "MVT", "LocVT", "=", "MVT", "::", "getIntegerVT", "(", "SVT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "VecCast", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "LocVT", ",", "Vec", ")", ";", "SDValue", "Shifted", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "LocVT", ",", "VecCast", ",", "Offset", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "LocVT", ",", "Shifted", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "LocVT", ")", ")", ";", "}", "else", "if", "(", "W", "==", "<NUM_LIT>", ")", "{", "unsigned", "Subreg", "=", "(", "X", "==", "<NUM_LIT>", ")", "?", "Hexagon", "::", "isub_lo", ":", "<NUM_LIT>", ";", "if", "(", "X", "==", "<NUM_LIT>", ")", "Subreg", "=", "Hexagon", "::", "isub_lo", ";", "else", "if", "(", "SVT", "==", "MVT", "::", "v2i32", "&&", "X", "==", "<NUM_LIT>", ")", "Subreg", "=", "Hexagon", "::", "isub_hi", ";", "else", "if", "(", "SVT", "==", "MVT", "::", "v4i16", "&&", "X", "==", "<NUM_LIT>", ")", "Subreg", "=", "Hexagon", "::", "isub_hi", ";", "else", "if", "(", "SVT", "==", "MVT", "::", "v8i8", "&&", "X", "==", "<NUM_LIT>", ")", "Subreg", "=", "Hexagon", "::", "isub_hi", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Bad offset", "<STR_LIT>", ")", ";", "N", "=", "DAG", ".", "getTargetExtractSubreg", "(", "Subreg", ",", "dl", ",", "MVT", "::", "i32", ",", "Vec", ")", ";", "}", "else", "if", "(", "SVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "N", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "}", "else", "if", "(", "SVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "N", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i64", ",", "Ops", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "N", "=", "DAG", ".", "getTargetExtractSubreg", "(", "Hexagon", "::", "isub_lo", ",", "dl", ",", "MVT", "::", "i32", ",", "N", ")", ";", "}", "else", "return", "SDValue", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", "," ]

[ "}" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ")", ")", "_", "mm_sll_pi32", "(", "_", "_", "m64", "_", "_", "m", ",", "_", "_", "m64", "_", "_", "count", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pslld", "(", "(", "_", "_", "v2si", ")", "_", "_", "m", ",", "(", "long", "long", ")", "_", "_", "count", ")", ";" ]

[ "StackOffset", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", ")", ";", "}", "else", "{", "FrameReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ")", ";", "}", "}" ]

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

[ "bool", "PPCInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "const", "TargetRegisterClass", "*", "RCs", "[", "]", "=", "{", "&", "PPC", "::", "CRRCRegClass", ",", "&", "PPC", "::", "CRBITRCRegClass", ",", "&", "PPC", "::", "CTRRCRegClass", ",", "&", "PPC", "::", "CTRRC8RegClass", "}", ";", "bool", "Found", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "for", "(", "unsigned", "c", "=", "<NUM_LIT>", ";", "c", "<", "array_lengthof", "(", "RCs", ")", "&&", "!", "Found", ";", "++", "c", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "RCs", "[", "c", "]", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "MO", ".", "isDef", "(", ")", "&&", "RC", "->", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "else", "if", "(", "MO", ".", "isRegMask", "(", ")", ")", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "IE", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "MO", ".", "clobbersPhysReg", "(", "*", "I", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "}", "}", "return", "Found", ";", "}" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "}" ]

[ "class", "UDFType", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "uimm16", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";" ]

[ "UI", "!=", "UE", ";", "++", "UI", ")", "{" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "if", "(", "(", "(", "N", "->", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "||", "N", "->", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "||", "N", "->", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ANY_EXTEND", ")", "&&", "N", "->", "getOperand", "(", "i", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", ")", "||", "isa", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "i", ")", ")", ")", "Inputs", ".", "push_back", "(", "N", "->", "getOperand", "(", "i", ")", ")", ";", "else", "BinOps", ".", "push_back", "(", "N", "->", "getOperand", "(", "i", ")", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "break", ";", "}", "while", "(", "!", "BinOps", ".", "empty", "(", ")", ")", "{", "SDValue", "BinOp", "=", "BinOps", ".", "back", "(", ")", ";", "BinOps", ".", "pop_back", "(", ")", ";", "if", "(", "!", "Visited", ".", "insert", "(", "BinOp", ".", "getNode", "(", ")", ")", ")", "continue", ";", "PromOps", ".", "push_back", "(", "BinOp", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "ie", "=", "BinOp", ".", "getNumOperands", "(", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "if", "(", "BinOp", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "i", "==", "<NUM_LIT>", ")", "continue", ";", "if", "(", "BinOp", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT_CC", "&&", "i", "!=", "<NUM_LIT>", "&&", "i", "!=", "<NUM_LIT>", ")", "continue", ";", "if", "(", "(", "(", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ANY_EXTEND", ")", "&&", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", ")", "||", "isa", "<", "ConstantSDNode", ">", "(", "BinOp", ".", "getOperand", "(", "i", ")", ")", ")", "{", "Inputs", ".", "push_back", "(", "BinOp", ".", "getOperand", "(", "i", ")", ")", ";", "}", "else", "if", "(", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT_CC", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "||", "BinOp", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ANY_EXTEND", ")", "{", "BinOps", ".", "push_back", "(", "BinOp", ".", "getOperand", "(", "i", ")", ")", ";", "}", "else", "{", "return", "SDValue", "(", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "ie", "=", "Inputs", ".", "size", "(", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Inputs", "[", "i", "]", ")", ")", "continue", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Inputs", "[", "i", "]", ".", "getNode", "(", ")", "->", "use_begin", "(", ")", ",", "UE", "=", "Inputs", "[", "i", "]", ".", "getNode", "(", ")", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "SDNode", "*", "User", "=", "*", "UI", ";", "if", "(", "User", "!=", "N", "&&", "!", "Visited", ".", "count", "(", "User", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "User", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", ")", "{", "if", "(", "User", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Inputs", "[", "i", "]", ")", "return", "SDValue", "(", ")", ";", "}", "else", "if", "(", "User", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT_CC", ")", "{", "if", "(", "User", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Inputs", "[", "i", "]", "||", "User", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Inputs", "[", "i", "]", ")", "return", "SDValue", "(", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "ie", "=", "PromOps", ".", "size", "(", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "PromOps", "[", "i", "]", ".", "getNode", "(", ")", "->", "use_begin", "(", ")", ",", "UE", "=", "PromOps", "[", "i", "]", ".", "getNode", "(", ")", "->", "use_end", "(", ")", ";" ]

[ "<FIXS>", "VEX", ",", "PS", ";", "<FIXE>" ]

[ "multiclass", "avx512_mask_testop_w", "bits", "<NUM_LIT>", ">", "opc", ",", "string", "OpcodeStr", ",", "SDNode", "OpNode", ">", "{", "defm", "W", ":", "avx512_mask_testop", "opc", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "VK16", ",", "OpNode", ">", ",", "<BUGS>", "VEX", ",", "TB", ";", "<BUGE>", "}", "defm", "KORTEST", ":", "avx512_mask_testop_w", "<NUM_LIT>", ",", "<STR_LIT>", ",", "X86kortest", ">", ";" ]

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

[ "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "DstIsDead", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ";", "bool", "DstIsKill", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "bool", "ImpIsDead", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ";", "TRI", "->", "splitReg", "(", "DstReg", ",", "DstLoReg", ",", "DstHiReg", ")", ";", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstLoReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstHiReg", ")", ";", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstLoReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstLoReg", ",", "RegState", "::", "Kill", ")", ";", "auto", "MI0", "=", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstLoReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstLoReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI0", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "auto", "MIBHI", "=", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstHiReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstHiReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", ".", "addReg", "(", "DstHiReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", ";", "if", "(", "ImpIsDead", ")", "MIBHI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead" ]

[ ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Optimize returned Attributes **********\\n", "<STR_LIT>", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "F", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "visit", "(", "F" ]

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

[ "(", "unspec", ":", "FMA4MODEF4", "[", "(", "minus", ":", "FMA4MODEF4", "(", "mult", ":", "FMA4MODEF4", "<BUGS>", "(", "match_operand", ":", "FMA4MODEF4", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "FMA4MODEF4", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "match_operand", ":", "FMA4MODEF4", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_FMA4_INTRINSIC", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "v2i32", ",", "v8i8", ",", "int_arm_neon_sdot", ">", ";" ]

[ "def", "VSDOTD", ":", "VDOT", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DPR", ",", "<STR_LIT>", ",", "<STR_LIT>", "," ]

[ "biteq", "=", "vec_and", "(", "biteq", ",", "(", "vec_uint4", ")", "vec_slo", "(", "(", "vec_uchar16", ")", "biteq", ",", "x", ".", "v", ")", ")", ";" ]

[ "vec_uint4", "nan_mask", "=", "(", "vec_uint4", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "vec_uchar16", "hihi_promote", "=", "(", "vec_uchar16", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "vec_uint4", "biteq", ";", "vec_uint4", "aabs", ";", "vec_uint4", "babs", ";", "vec_uint4", "a_gt", ";", "vec_uint4", "ahi_inf", ";", "vec_uint4", "anan", ";", "vec_uint4", "result", ";", "union", "{", "vec_uchar16", "v", ";", "int", "i", "[", "<NUM_LIT>", "]", ";", "}", "x", ";", "x", ".", "i", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", "<<", "<NUM_LIT>", ";", "aabs", "=", "vec_and", "(", "(", "vec_uint4", ")", "a", ",", "sign_mask", ")", ";", "babs", "=", "vec_and", "(", "(", "vec_uint4", ")", "b", ",", "sign_mask", ")", ";", "biteq", "=", "(", "vec_uint4", ")", "vec_cmpeq", "(", "(", "vec_uint4", ")", "aabs", ",", "(", "vec_uint4", ")", "babs", ")", ";" ]

[ ")", ")" ]

[ "(", "usdiv", ":", "ALL1Q", "(", "reg", ":", "ALL1Q", "<NUM_LIT>", ")", "(", "reg", ":", "ALL1Q", "<NUM_LIT>", ")" ]

[ ",", "RV", "->", "getType", "(", ")", ")", ";" ]

[ "CallingConv", "::", "ID", "CC", "=", "F", ".", "getCallingConv", "(", ")", ";", "if", "(", "Ret", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", ")", "{", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "GetReturnInfo", "(", "CC", ",", "F", ".", "getReturnType", "(", ")", ",", "F", ".", "getAttributes", "(", ")", ",", "Outs", ",", "TLI", ",", "DL", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ValLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "F", ".", "isVarArg", "(", ")", ",", "*", "FuncInfo", ".", "MF", ",", "ValLocs", ",", "I", "->", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForCall", "(", "CC", ",", "true", ",", "F", ".", "isVarArg", "(", ")", ")", ")", ";", "const", "Value", "*", "RV", "=", "Ret", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Register", "Reg", "=", "getRegForValue", "(", "RV", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "ValLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "CCValAssign", "&", "VA", "=", "ValLocs", "[", "<NUM_LIT>", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "return", "false", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "Reg", "+", "VA", ".", "getValNo", "(", ")", ";", "EVT", "RVEVT", "=", "TLI", ".", "getValueType", "(", "DL" ]

[ ";" ]

[ "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate" ]

[ "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "BV", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{" ]

[ "SDValue", "InDouble", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "InDouble", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Subtarget", "->", "hasFP64", "(", ")", ")", "return", "DCI", ".", "CombineTo", "(", "N", ",", "InDouble", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "InDouble", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDNode", "*", "InNode", "=", "InDouble", ".", "getNode", "(", ")", ";", "if", "(", "ISD", "::", "isNormalLoad", "(", "InNode", ")", "&&", "InNode", "->", "hasOneUse", "(", ")", "&&", "InNode", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "f64", "&&", "InNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FrameIndex", "&&", "!", "cast", "<", "LoadSDNode", ">", "(", "InNode", ")", "->", "isVolatile", "(", ")", ")", "{", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "InNode", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "LD", ")", ";", "SDValue", "BasePtr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "SDValue", "NewLD1", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "DL", ",", "LD", "->", "getChain", "(", ")", ",", "BasePtr", ",", "LD", "->", "getPointerInfo", "(", ")", ",", "LD", "->", "getAlignment", "(", ")", ",", "LD", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "OffsetPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "NewLD2", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "DL", ",", "LD", "->", "getChain", "(", ")", ",", "OffsetPtr", ",", "LD", "->", "getPointerInfo", "(", ")", ".", "getWithOffset", "(", "<NUM_LIT>", ")", ",", "std", "::", "min", "(", "<NUM_LIT>", "U", ",", "LD", "->", "getAlignment", "(", ")", ")", ",", "LD", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "LD", ",", "<NUM_LIT>", ")", ",", "NewLD2", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "DCI", ".", "DAG", ".", "getDataLayout", "(", ")", ".", "isBigEndian", "(", ")", ")", "std", "::", "swap", "(", "NewLD1", ",", "NewLD2", ")", ";", "SDValue", "Result", "=", "DCI", ".", "CombineTo", "(", "N", ",", "NewLD1", ",", "NewLD2", ")", ";", "return", "Result", ";", "}", "if", "(", "InDouble", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "isa", "<", "ConstantSDNode", ">", "(", "InDouble", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "BV", "=", "InDouble", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "BVSwap", "=", "BV", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ";", "while", "(", "(", "BV", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "||", "BV", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "(", "BV", ".", "getValueType", "(", ")", "==", "MVT", "::", "v2f64", "||", "BV", ".", "getValueType", "(", ")", "==", "MVT", "::", "v2i64", ")", ")", "{", "BVSwap", "=", "BV", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ";", "BV", "=", "BV", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "BV", ".", "getValueType", "(", ")", "!=", "MVT", "::", "v4i32", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Offset", "=", "InDouble", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "BV", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", ")", "{", "SDValue", "Op0", "=", "BV", ".", "getOperand", "(", "Offset", ")", ";", "SDValue", "Op1", "=", "BV", ".", "getOperand", "(", "Offset", "+", "<NUM_LIT>", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", "&&", "BVSwap", ")", "std", "::", "swap", "(", "Op0", ",", "Op1", ")", ";", "return", "DCI", ".", "DAG", ".", "getMergeValues", "(", "{", "Op0", ",", "Op1", "}", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "SDValue", "Op0", ",", "Op1", ";", "while", "(", "BV", ".", "getOpcode", "(", ")", "==", "ISD", "::", "INSERT_VECTOR_ELT", ")", "{" ]

[ ";" ]

[ "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "if", "(", "const", "VEMCExpr", "*", "SExpr", "=", "dyn_cast", "<", "VEMCExpr", ">", "(", "Expr", ")", ")", "{", "MCFixupKind", "Kind", "=", "(", "MCFixupKind", ")", "SExpr", "->", "getFixupKind", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "Expr", ",", "Kind", ")", ")", ";", "return", "<NUM_LIT>", ";", "}", "int64_t", "Res" ]

[ "=", "RdHi", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "RdLo", ";", "bits", "<", "<NUM_LIT>", ">", "RdHi", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

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

[ "(", "define_mode_iterator", "INT", "[", "QI", "HI" ]

[ "static", "void", "replace_mov_pcrel_step1", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "unspec", ";", "rtx", "opnds", "[", "<NUM_LIT>", "]", ";", "rtx_insn", "*", "new", "_", "insns", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "opnds", "[", "<NUM_LIT>", "]", "=", "SET_DEST", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "CONST", ")", ";", "unspec", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "<NUM_LIT>", ")", "==", "UNSPEC_HW1_LAST_PCREL", ")", ";", "opnds", "[", "<NUM_LIT>", "]", "=", "XVECEXP", "(", "unspec", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "opnds", "[", "<NUM_LIT>", "]", ")", "!=", "SYMBOL_REF", ")", "return", ";", "start_sequence", "(", ")", ";", "if", "(", "flag_pic", "!=", "<NUM_LIT>", ")", "{", "if", "(", "TARGET_32BIT", ")", "emit_insn", "(", "gen_mov_got32_step1_32bit", "(", "opnds", "[", "<NUM_LIT>", "]", ",", "opnds", "[", "<NUM_LIT>", "]", ")", ")", ";", "else", "emit_insn", "(", "gen_mov_got32_step1", "(", "opnds", "[", "<NUM_LIT>", "]", ",", "opnds", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "new", "_", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "replace_insns", "(", "insn", ",", "new", "_", "insns", ")", ";", "}" ]

[ "Do", "the", "first", "replacement", "step", "in", "tilegx_fixup_pcrel_references", "." ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_cmp_ps_mask", "(", "_", "_", "m256", "_", "_", "X", ",", "_", "_", "m256", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cmpps256_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "X", ",", "(", "_", "_", "v8sf", ")", "_", "_", "Y", ",", "_", "_", "P", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "void", "A57ChainingConstraint", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "const", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "LiveIntervals", "&", "LIs", "=", "G", ".", "getMetadata", "(", ")", ".", "LIS", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MF", ")", "{", "Chains", ".", "clear", "(", ")", ";", "for", "(", "const", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "toDel", ";", "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Killing chain ", "<STR_LIT>", "<<", "PrintReg", "(", "r", ",", "TRI", ")", "<<", "<STR_LIT>", " at ", "<STR_LIT>", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "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>", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ra", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "}" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "}" ]

[ "bool", "atInsnStart", "=", "true", ";", "unsigned", "Length", "=", "<NUM_LIT>", ";", "const", "unsigned", "MaxInstLength", "=", "MAI", ".", "getMaxInstLength", "(", "STI", ")", ";", "for", "(", ";", "*", "Str", ";", "++", "Str", ")", "{", "if", "(", "*", "Str", "==", "'", "\\n", "'", "||", "strncmp", "(", "Str", ",", "MAI", ".", "getSeparatorString", "(", ")", ",", "strlen", "(", "MAI", ".", "getSeparatorString", "(", ")", ")", ")", "==", "<NUM_LIT>", ")", "atInsnStart", "=", "true", ";", "if", "(", "atInsnStart", "&&", "!", "std", "::", "isspace", "(", "static_cast", "<", "unsigned", "char", ">", "(", "*", "Str", ")", ")", ")", "{", "Length", "+=", "MaxInstLength", ";", "atInsnStart", "=", "false", ";" ]

[ "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_blend_epi64", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "W", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_blendmq_128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")" ]

[ "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "ZeroReg", ")", "return", "false", ";" ]

[ "if", "(", "!", "MI", "||", "MI", "->", "getParent", "(", ")", "!=", "&", "MBB", "||", "(", "unsigned", ")", "MI", "->", "getOpcode", "(", ")", "!=", "MulOpc", ")", "return", "false", ";", "assert", "(", "MI", "->", "getNumOperands", "(", ")", ">=", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "MAdd/MSub must have a least 4 regs", "<STR_LIT>", ")", ";" ]

[ "AlignInBits", ",", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ".", "getAddressSpace", "(", ")", ",", "Opcode", ")", ";" ]

[ "return", "shouldWidenLoad", "(", "ST", ",", "Query", ".", "MMODescrs", "[", "<NUM_LIT>", "]", ".", "SizeInBits", ",", "Query", ".", "MMODescrs", "[", "<NUM_LIT>", "]", "." ]

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeUNPCKHMask", "(", "VT", ",", "Mask", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeUNPCKLMask", "(", "VT", ",", "Mask", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeMOVHLPSMask", "(", "NumElems", ",", "Mask", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeMOVLHPSMask", "(", "NumElems", ",", "Mask", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodePSHUFMask", "(", "VT", ",", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodePSHUFHWMask", "(", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodePSHUFLWMask", "(", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "Mask", ".", "push_back", "(", "NumElems", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "{", "Mask", ".", "push_back", "(", "i", ")", ";", "}", "break", ";", "}" ]

[ "getDefault", "(", ")", ";" ]

[ "llvm", "::", "call_once", "(", "InitializeDefaultVGPRRegisterAllocatorFlag", ",", "initializeDefaultVGPRRegisterAllocatorOnce", ")", ";", "RegisterRegAlloc", "::", "FunctionPassCtor", "Ctor", "=", "VGPRRegisterRegAlloc", "::" ]

[ "<STR_LIT>", ";" ]

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

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

[ "bits", "<", "<NUM_LIT>", ">", "imm5", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "bits", "<", "<NUM_LIT>", ">", "Zt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "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", ";" ]

[ "DONE" ]

[ "(", "match_operand", ":", "<", "V_HALF", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "emit_move_insn", "(", "simplify_gen_subreg", "(", "<", "V_HALF", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ",", "GET_MODE_SIZE", "(", "<", "V_HALF", ">", "mode", ")", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ ")", ";" ]

[ "if", "(", "isMemNoOffset", "(", "false", ",", "<NUM_LIT>", ")", ")", "return", "true", ";", "return", "isMemNoOffset", "(", "false", ",", "<NUM_LIT>" ]

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

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

[ "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";" ]

[ "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "delta", "=", "-", "delta", ";", "emit_insn", "(", "gen_add2_insn", "(", "op_reg", ",", "GEN_INT", "(", "delta", ")", ")", ")", ";", "new", "_", "addr", "=", "op_reg", ";", "}", "break", ";", "case", "PRE_MODIFY", ":", "op0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "base_reg_operand", "(", "op0", ",", "Pmode", ")", "||", "GET_CODE", "(", "op1", ")", "!=", "PLUS", "||", "!", "rtx_equal_p", "(", "op0", ",", "XEXP", "(", "op1", ",", "<NUM_LIT>", ")", ")", ")", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_PRE_MODIFY", ")", "==", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "new", "_", "addr", "=", "reg", ";", "}", "break", ";", "case", "AND", ":", "op0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_AND_M16", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "REG_P", "(", "op0", ")", "||", "SUBREG_P", "(", "op0", ")", ")", "op_reg", "=", "op0", ";", "else", "if", "(", "GET_CODE", "(", "op1", ")", "==", "PLUS", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "op1", ")", ")", ";", "op_reg", "=", "scratch", ";", "}", "else", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "and", "_", "op", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "scratch", ")", ",", "op_reg", ",", "op1", ")", ";", "cc_clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "CCmode", ")", ")", ";", "rv", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "gen_rtx_SET", "(", "scratch", ",", "and", "_", "op", ")", ",", "cc_clobber", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rv", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "break", ";", "case", "REG", ":", "case", "SUBREG", ":", "if", "(", "!", "base_reg_operand", "(", "addr", ",", "GET_MODE", "(", "addr", ")", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "break", ";", "case", "PLUS", ":", "op0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "base_reg_operand", "(", "op0", ",", "Pmode", ")", ")", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "else", "if", "(", "int_reg_operand", "(", "op1", ",", "Pmode", ")", ")", "{", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_INDEXED", ")", "==", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "}", "else", "if", "(", "mode_supports_dq_form", "(", "mode", ")", "&&", "CONST_INT_P", "(", "op1", ")", ")", "{", "if", "(", "(", "(", "addr_mask", "&", "RELOAD_REG_QUAD_OFFSET", ")", "==", "<NUM_LIT>", ")", "||", "!", "quad_address_p", "(", "addr", ",", "mode", ",", "false", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "}", "else", "if", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "addr", ",", "false", ",", "true", ")", ")", "{", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_OFFSET", ")", "==", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "}", "else", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "break", ";", "case", "LO_SUM", ":", "op0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "op1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "base_reg_operand", "(", "op0", ",", "Pmode", ")", ")", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "else", "if", "(", "int_reg_operand", "(", "op1", ",", "Pmode", ")", ")", "{", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_INDEXED", ")", "==", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "}", "else", "if", "(", "mode_supports_dq_form", "(", "mode", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "else", "if", "(", "legitimate_lo_sum_address_p", "(", "mode", ",", "addr", ",", "false", ")", ")", "{", "if", "(", "(", "addr_mask", "&", "RELOAD_REG_OFFSET", ")", "==", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "addr", ")", ")", ";", "new", "_", "addr", "=", "scratch", ";", "}", "}", "else", "rs6000_secondary_reload_fail", "(", "_", "_", "LINE__", ",", "reg", ",", "mem", ",", "scratch", ",", "store_p", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "LABEL_REF", ":", "rs6000_emit_move", "(", "scratch", ",", "addr", ",", "Pmode", ")", ";", "new", "_", "addr", "=", "scratch", ";", "break", ";", "default", ":" ]

[ "static", "rtx", "mips_expand_builtin_bposge", "(", "enum", "mips_builtin_type", "builtin_type", ",", "rtx", "target", ")", "{", "rtx", "condition", ",", "cmp_result", ";", "int", "cmp_value", ";", "if", "(", "target", "==", "<NUM_LIT>", "||", "GET_MODE", "(", "target", ")", "!=", "SImode", ")", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "cmp_result", "=", "gen_rtx_REG", "(", "CCDSPmode", ",", "CCDSP_PO_REGNUM", ")", ";", "if", "(", "builtin_type", "==", "MIPS_BUILTIN_BPOSGE32", ")", "cmp_value", "=", "<NUM_LIT>", ";", "else", "gcc_assert", "(", "<NUM_LIT>", ")", ";", "condition", "=", "gen_rtx_GE", "(", "VOIDmode", ",", "cmp_result", ",", "GEN_INT", "(", "cmp_value", ")", ")", ";", "return", "mips_builtin_branch_and_move", "(", "condition", ",", "target", ",", "const1_rtx", ",", "const0_rtx", ")", ";", "}" ]

[ "Expand", "a", "bposge", "builtin", "of", "type", "BUILTIN_TYPE", ".", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "boolean", "result", ".", "The", "sequence", "we", "want", "is", "li", "target", ",", "0", "bposge", "*", "label1", "j", "label2", "label1", ":", "li", "target", ",", "1", "label2", ":" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_rcp14_ps", "(", "_", "_", "m256", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_rcp14ps256_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "<NUM_LIT>", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "}", "}", "else", "if", "(", "shouldTryToSpillVGPRs", "(", "MF", ")", "&&", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_SAVE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_SAVE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "<NUM_LIT>", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "SIInstrInfo::storeRegToStackSlot - Do not know how to", "<STR_LIT>", "<STR_LIT>", " spill register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "AMDGPU", "::", "VGPR0", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "}" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_cvtph_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_vcvtph2ps256_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "mm256_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "}" ]

[ "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "O", "<<", "Op", ".", "getImm", "(", ")", ";", "return", ";", "}", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown operand kind in printOperand", "<STR_LIT>", ")", ";", "printExpr", "(", "Op", ".", "getExpr", "(", ")", ",", "&", "MAI", ",", "O", ")", ";" ]

[ "bool", "IA64AsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "O", "<<", "<STR_LIT>", "\\n\\n// br.call targets referenced (and not defined) above: \\n", "<STR_LIT>", ";", "for", "(", "std", "::", "set", "<", "std", "::", "string", ">", "::", "iterator", "i", "=", "ExternalFunctionNames", ".", "begin", "(", ")", ",", "e", "=", "ExternalFunctionNames", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "O", "<<", "<STR_LIT>", "\\t.global ", "<STR_LIT>", "<<", "*", "i", "<<", "<STR_LIT>", "\\n\\t.type ", "<STR_LIT>", "<<", "*", "i", "<<", "<STR_LIT>", ", @function\\n", "<STR_LIT>", ";", "}", "O", "<<", "<STR_LIT>", "\\n\\n", "<STR_LIT>", ";", "O", "<<", "<STR_LIT>", "\\n\\n// (external) symbols referenced (and not defined) above: \\n", "<STR_LIT>", ";", "for", "(", "std", "::", "set", "<", "std", "::", "string", ">", "::", "iterator", "i", "=", "ExternalObjectNames", ".", "begin", "(", ")", ",", "e", "=", "ExternalObjectNames", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "O", "<<", "<STR_LIT>", "\\t.global ", "<STR_LIT>", "<<", "*", "i", "<<", "<STR_LIT>", "\\n\\t.type ", "<STR_LIT>", "<<", "*", "i", "<<", "<STR_LIT>", ", @object\\n", "<STR_LIT>", ";", "}", "O", "<<", "<STR_LIT>", "\\n\\n", "<STR_LIT>", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

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

[ "class", "DForm_4", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ",", "InstrItinClass", "itin", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "opcode", ",", "OOL", ",", "IOL", ",", "asmstr", ",", "itin", ">", "{", "bits", "<", "<NUM_LIT>", ">", "B", ";", "bits", "<", "<NUM_LIT>", ">", "A", ";", "bits", "<", "<NUM_LIT>", ">", "C", ";", "let", "Pattern", "=", "pattern", ";" ]

[ "StackOffset", "HexagonFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "hasStackRealignment", "(", "MF", ")", ";", "bool", "NoOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Register", "SP", "=", "HRI", ".", "getStackRegister", "(", ")", ";", "Register", "FP", "=", "HRI", ".", "getFrameRegister", "(", ")", ";", "Register", "AP", "=", "HMFI", ".", "getStackAlignBasePhysReg", "(", ")", ";", "if", "(", "AP", "==", "<NUM_LIT>", ")", "AP", "=", "FP", ";", "bool", "UseFP", "=", "false", ",", "UseAP", "=", "false", ";", "if", "(", "NoOpt", "&&", "!", "HasExtraAlign", ")", "UseFP", "=", "true", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "||", "MFI", ".", "isObjectPreAllocated", "(", "FI", ")", ")", "{", "UseFP", "|=", "(", "HasAlloca", "||", "HasExtraAlign", ")", ";", "}", "else", "{", "if", "(", "HasAlloca", ")", "{", "if", "(", "HasExtraAlign", ")", "UseAP", "=", "true", ";", "else", "UseFP", "=", "true", ";", "}", "}", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "assert", "(", "(", "HasFP", "||", "!", "UseFP", ")", "&&", "<STR_LIT>", "This function must have frame pointer", "<STR_LIT>", ")", ";", "if", "(", "Offset", ">", "<NUM_LIT>", "&&", "!", "HasFP", ")", "Offset", "-=", "<NUM_LIT>", ";", "if", "(", "UseFP", ")", "FrameReg", "=", "FP", ";", "else", "if", "(", "UseAP", ")", "FrameReg", "=", "AP", ";", "else", "FrameReg", "=", "SP", ";", "int", "RealOffset", "=", "Offset", ";", "if", "(", "!", "UseFP", "&&", "!", "UseAP", ")", "RealOffset", "=", "FrameSize", "+", "Offset", ";", "return", "StackOffset", "::", "getFixed", "(", "RealOffset", ")", ";", "}" ]

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