Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "vrshrn_n_u32", "(", "uint32x4_t", "_", "_", "a", ",", "const", "int", "_", "_", "b", ")", "{", "return", "(", "uint16x4_t", ")", "_", "_", "builtin_neon_vrshrn_nv4si", "(", "(", "int32x4_t", ")", "_" ]

[ "bool", "X86AsmBackend", "::", "allowAutoPadding", "(", ")", "const", "{", "return", "(", "AlignBoundary", "!=", "Align", "(", "<NUM_LIT>", ")", "&&", "AlignBranchType", "!=", "X86", "::", "AlignBranchNone", ")", ";", "}" ]

[ "Return", "true", "if", "this", "target", "might", "automatically", "pad", "instructions", "and", "thus", "need", "to", "emit", "padding", "enable/disable", "directives", "around", "sensative", "code", "." ]

[ ",", "(", "_", "_", "mmask8", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpshldv_v8hi_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "C", ",", "(", "_", "_", "v8hi", ")", "_", "_", "D" ]

[ "Triple", "&", "TT", ")", "{" ]

[ "static", "bool", "isCode16", "(", "const" ]

[ "SDValue", "XCoreSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "unsigned", "SizeBitWidth", "=", "Size", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "!", "AlwaysInline", "&&", "(", "Align", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Size", ",", "APInt", "(", "SizeBitWidth", ",", "<NUM_LIT>", ")", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "<STR_LIT>", "__memcpy_4", "<STR_LIT>", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "<NUM_LIT>", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

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

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

[ "{" ]

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

[ "}" ]

[ "int", "mapip_get_return_regs", "(", ")", "{", "return", "R0_REGNUM", ";" ]

[ "}" ]

[ "const", "XtensaSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";" ]

[ "{" ]

[ "bool", "OmitCallSeq", "=", "NumBytes", "==", "<NUM_LIT>", "&&", "!", "CLI", ".", "IsPatchPoint", ";", "assert", "(", "(", "!", "IsSibCall", "||", "OmitCallSeq", ")", "&&", "<STR_LIT>", "Should not get callseq for sibcalls", "<STR_LIT>", ")", ";", "if", "(", "!", "OmitCallSeq", ")", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "NumBytes", ",", "<NUM_LIT>", ",", "DL", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "realArgIdx", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ",", "++", "realArgIdx", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "realArgIdx", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "realArgIdx", "]", ".", "Flags", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "if", "(", "Outs", "[", "realArgIdx", "]", ".", "ArgVT", "==", "MVT", "::", "i1", ")", "{", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i1", ",", "Arg", ")", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "MVT", "::", "i8", ",", "Arg", ")", ";", "}", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "FPExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "if", "(", "realArgIdx", "==", "<NUM_LIT>", "&&", "Flags", ".", "isReturned", "(", ")", "&&", "!", "Flags", ".", "isSwiftSelf", "(", ")", "&&", "Outs", "[", "<NUM_LIT>", "]", ".", "VT", "==", "MVT", "::", "i64", ")", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "unexpected calling convention register assignment", "<STR_LIT>", ")", ";", "assert", "(", "!", "Ins", ".", "empty", "(", ")", "&&", "Ins", "[", "<NUM_LIT>", "]", ".", "VT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "unexpected use of 'returned'", "<STR_LIT>", ")", ";", "IsThisReturn", "=", "true", ";", "}", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "DstAddr", ";", "MachinePointerInfo", "DstInfo", ";", "uint32_t", "BEAlign", "=", "<NUM_LIT>", ";", "unsigned", "OpSize", "=", "Flags", ".", "isByVal", "(", ")", "?", "Flags", ".", "getByValSize", "(", ")", "*", "<NUM_LIT>", ":", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "OpSize", "=", "(", "OpSize", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "if", "(", "!", "Subtarget", "->", "isLittleEndian", "(", ")", "&&", "!", "Flags", ".", "isByVal", "(", ")", "&&", "!", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "{", "if", "(", "OpSize", "<", "<NUM_LIT>", ")", "BEAlign", "=", "<NUM_LIT>", "-", "OpSize", ";", "}", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "int32_t", "Offset", "=", "LocMemOffset", "+", "BEAlign", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "Offset", ",", "DL", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "StackPtr", ",", "PtrOff", ")", ";", "if", "(", "IsTailCall", ")", "{", "Offset", "=", "Offset", "+", "FPDiff", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "OpSize", ",", "Offset", ",", "true", ")", ";", "DstAddr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "PtrVT", ")", ";", "DstInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ";", "Chain", "=", "addTokenForArgument", "(", "Chain", ",", "DAG", ",", "MF", ".", "getFrameInfo", "(", ")", ",", "FI", ")", ";", "}", "else", "{", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "Offset", ",", "DL", ")", ";", "DstAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "StackPtr", ",", "PtrOff", ")", ";", "DstInfo", "=", "MachinePointerInfo", "::", "getStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "LocMemOffset", ")", ";", "}", "if", "(", "Outs", "[", "i", "]", ".", "Flags", ".", "isByVal", "(", ")", ")", "{", "SDValue", "SizeNode", "=", "DAG", ".", "getConstant", "(", "Outs", "[", "i", "]", ".", "Flags", ".", "getByValSize", "(", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "SDValue", "Cpy", "=", "DAG", ".", "getMemcpy", "(", "Chain", ",", "DL", ",", "DstAddr", ",", "Arg", ",", "SizeNode", ",", "Outs", "[", "i", "]", ".", "Flags", ".", "getByValAlign", "(", ")", ",", "false", ",", "false", ",", "false", ",", "DstInfo", ",", "MachinePointerInfo", "(", ")", ")", ";", "MemOpChains", ".", "push_back", "(", "Cpy", ")", ";", "}", "else" ]

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

[ "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "createMips16TargetLowering", "(", "TM", ",", "STI", ")", ";", "return", "createMipsSETargetLowering", "(", "TM" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ ":", "$", "src1", ",", "(", "load", "addr", ":", "$", "src2", ")", ")", ")", "]", ",", "d", ">", ",", "Sched", "<", "[", "sched", ".", "Folded", ",", "ReadAfterLd", "]", ">", ";" ]

[ "def", "rm", ":", "SI", "<", "opc", ",", "MRMSrcMem", ",", "(", "outs", "RC", ":", "$", "dst", ")", ",", "(", "ins", "RC", ":", "$", "src1", ",", "x86memop", ":", "$", "src2", ")", ",", "!", "if", "(", "Is2Addr", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ")", ",", "[", "(", "set", "RC", ":", "$", "dst", ",", "(", "OpNode", "RC" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "AArch64AsmParser", "::", "tryParseVectorRegister", "(", "int", "&", "Reg", ",", "StringRef", "&", "Kind", ",", "RegKind", "MatchKind", ")", "{", "<FIXE>" ]

[ "return", "false", ";", "}", "<BUGS>", "<BUGE>", "OperandMatchResultTy", "<BUGS>", "AArch64AsmParser", "::", "tryParseSVERegister", "(", "int", "&", "Reg", ",", "StringRef", "&", "Kind", ",", "RegKind", "MatchKind", ")", "{", "<BUGE>", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign" ]

[ "<FIXS>", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "<FIXE>" ]

[ "mips_expand_vec_minmax", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "(", "*", "cmp", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "bool", "min_p", ")", "{", "<BUGS>", "enum", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "<BUGE>", "rtx", "tc", ",", "t0", ",", "t1", ",", "x", ";", "tc", "=", "gen_reg_rtx", "(", "vmode", ")", ";" ]

[ ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";" ]

[ "}", "break", ";", "}", "default", ":", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results" ]

[ "]", ")" ]

[ "(", "ALUOP2", ":", "EQD", "(", "zero_extend", ":", "EQD", "(", "match_operand", ":", "EQD", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ALUOP2", ":", "EQD", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "SI annotate control flow", "<STR_LIT>", ";", "}" ]

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

[ "return", "(", "unsigned", ")", "Priv", "->", "LoopBound", ";" ]

[ "report_fatal_error", "(", "<STR_LIT>", "Single-path code generation failed! ", "<STR_LIT>", "<STR_LIT>", "Scope has no bound. MBB: '", "<STR_LIT>", "+", "(", "getHeader", "(", ")", "->", "getMBB", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "'!", "<STR_LIT>", ")", ";", "}" ]

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

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

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

[ "APInt", "NumActiveElems", "=", "IsSigned", "?", "Y", ".", "ssub_ov", "(", "X", ",", "Overflow", ")", ":", "Y", ".", "usub_ov", "(", "X", ",", "Overflow", ")", ";", "if", "(", "Overflow", ")", "return", "SDValue", "(", ")", ";", "if", "(", "IsEqual", ")", "{", "APInt", "One", "(", "NumActiveElems", ".", "getBitWidth", "(", ")", ",", "<NUM_LIT>", ",", "IsSigned", ")", ";", "NumActiveElems", "=", "IsSigned", "?", "NumActiveElems", ".", "sadd_ov", "(", "One", ",", "Overflow", ")", ":", "NumActiveElems", ".", "uadd_ov", "(", "One", ",", "Overflow", ")", ";", "if", "(", "Overflow", ")", "return", "SDValue", "(", ")", ";", "}", "std", "::", "optional", "<", "unsigned", ">", "PredPattern", "=", "getSVEPredPatternFromNumElements", "(", "NumActiveElems", ".", "getZExtValue", "(", ")", ")", ";", "unsigned", "MinSVEVectorSize", "=", "std", "::", "max", "(", "DAG", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getMinSVEVectorSizeInBits", "(", ")" ]

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

[ "void", "LLVMInitializeMipsDisassembler", "(", ")", "{", "TargetRegistry", "::", "RegisterMCDisassembler", "(", "TheMipsTarget", ",", "createMipsDisassembler", ")", ";", "TargetRegistry", "::", "RegisterMCDisassembler", "(", "TheMipselTarget", ",", "createMipselDisassembler", ")", ";", "TargetRegistry", "::", "RegisterMCDisassembler", "(", "TheMips64Target", "," ]

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

[ "void", "AArch64PassConfig", "::", "addPreGlobalInstructionSelect" ]

[ "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "default", ":", "return", "UNSUPPORTED", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "def", "SRL32", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "return", "!", "N", "-", ">", "isExactlyValue", "(", "+", "<NUM_LIT>", ".", "<NUM_LIT>", ")", "&", "&", "!", "checkConvertToNonDenormSingle", "(", "APFloatOfN", ")", ";", "}", "]", ">", ";", "def", "getFPAs64BitIntHi", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "APFloatOfN", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "bool", "Unused", ";", "APFloatOfN", ".", "convert", "(", "APFloat", ":", ":", "IEEEdouble", "(", ")", ",", "APFloat", ":", ":", "rmNearestTiesToEven", ",", "&", "Unused", ")", ";", "uint32_t", "Hi", "=", "(", "uint32_t", ")", "(", "(", "APFloatOfN", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", ">", ">", "<NUM_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "Hi", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "getFPAs64BitIntLo", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "APFloatOfN", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "bool", "Unused", ";", "APFloatOfN", ".", "convert", "(", "APFloat", ":", ":", "IEEEdouble", "(", ")", ",", "APFloat", ":", ":", "rmNearestTiesToEven", ",", "&", "Unused", ")", ";", "uint32_t", "Lo", "=", "(", "uint32_t", ")", "(", "APFloatOfN", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "Lo", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "imm34", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "N", "-", ">", "getSExtValue", "(", ")", ")", ";", "}", "]", ">", ";", "def", "getImmAs64BitInt", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI64Imm", "(", "N", "-", ">", "getSExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";", "def", "SHL32", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "getI32Imm", "(", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ")", ";", "}", "]", ">", ";" ]

[ "int", "arm_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "RTX_CODE", "outer", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "<NUM_LIT>", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "(", "mode", "==", "DFmode", "&&", "(", "TARGET_SOFT_FLOAT", "||", "TARGET_VFP", ")", ")", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "use_ldrd", "&&", "GET_CODE", "(", "x", ")", "==", "POST_MODIFY", "&&", "GET_CODE", "(", "addend", ")", "==", "REG", ")", "return", "<NUM_LIT>", ";", "return", "(", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "addend", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", ")", ")", "return", "<NUM_LIT>", ";", "else", "if", "(", "mode", "==", "TImode", ")", "return", "<NUM_LIT>", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop0", ",", "outer", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "ARM", "state", "address", "operand", "." ]

[ "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "DI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")" ]

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

[ "class", "MIMG_Store_Helper", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "string", "asm", ",", "RegisterClass", "data_rc", ",", "RegisterClass", "addr_rc", ",", "string", "dns", "=", "<STR_LIT>", ">", ":", "MIMG_gfx6789", "<", "op", ",", "(", "outs", ")", ",", "dns", ">", "{", "let", "InOperandList", "=", "!", "con", "(", "(", "ins", "data_rc", ":", "$", "vdata", ",", "addr_rc", ":", "$", "vaddr", ",", "SReg_256", ":", "$", "srsrc", ",", "DMask", ":", "$", "dmask", ",", "UNorm", ":", "$", "unorm", ",", "GLC", ":", "$", "glc", ",", "SLC", ":", "$", "slc", ",", "R128A16", ":", "$", "r128", ",", "TFE", ":", "$", "tfe", ",", "LWE", ":", "$", "lwe", ",", "DA", ":", "$", "da", ")", ",", "!", "if", "(", "BaseOpcode", ".", "HasD16", ",", "(", "ins", "D16", ":", "$", "d16", ")", ",", "(", "ins", ")", ")", ")", ";", "let", "AsmString", "=", "asm", "#", "<STR_LIT>", "#", "!", "if", "(", "BaseOpcode", "." ]

[ "bool", "BTFDebug", "::", "InstLower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "->", "getName", "(", ")", ".", "str", "(", ")", "]", ";", "OutMI", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Emit", "proper", "patchable", "instructions", "." ]

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

[ "(", "div", ":", "V4SF", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

[ ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_code", "<STR_LIT>" ]

[ "ARM", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";" ]

[ "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "<NUM_LIT>", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "<NUM_LIT>", ";", "Offset", "+=", "MFI", ".", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "<NUM_LIT>", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", ".", "getLocalFrameMaxAlign", "(", ")", ">", "TFI", "->", "getStackAlign", "(", ")", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", "," ]

[ "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";" ]

[ "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "ProcessInstruction", "(", "Inst", ",", "IDLoc", ",", "Out", ")", ")", "return", "true", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction use requires option to be enabled", "<STR_LIT>", ")", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "NyuziMnemonicSpellCheck", "(", "(", "(", "NyuziOperand", "&", ")", "*", "Operands", "[", "<NUM_LIT>", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction", "<STR_LIT>", "+", "Suggestion", ")", ";", "}", "case", "Match_InvalidOperand", ":", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "NyuziOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}" ]

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

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

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

[ "def", "v8i16_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128_lo", ",", "VectorIndexH", ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4i32", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "extract_high_v8i16", "V128", ":", "$", "Rn", ")", ",", "(", "extract_high_v8i16", "(", "AArch64duplane16", "(", "v8i16", "V128_lo", ":", "$", "Rm", ")", ",", "VectorIndexH", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";" ]

[ "MVT", "::", "i32", ",", "Sub", ")", ";" ]

[ "SDValue", "Size", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "Register", "SPReg", "=", "getStackPointerRegisterToSaveRestore", "(", ")", ";", "SDValue", "StackPointer", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "SPReg", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "MVT", "::", "i32", ",", "StackPointer", ",", "Size", ")", ";", "SDValue", "ArgAdjust", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", "," ]

[ "SFDF", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":" ]

[ "}" ]

[ "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isTargetWindows", "(", ")", ")", "return", "false", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "unsigned", "StackProbeSize", "=", "<NUM_LIT>", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "<STR_LIT>", "stack-probe-size", "<STR_LIT>", ")", ")", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "stack-probe-size", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "StackProbeSize", ")", ";", "return", "(", "StackSizeInBytes", ">=", "StackProbeSize", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "<STR_LIT>", "no-stack-arg-probe", "<STR_LIT>", ")", ";" ]

[ "getRegClass", "(", "R", ")", ";" ]

[ "bool", "HexagonEarlyIfConversion", "::", "isPredicate", "(", "unsigned", "R", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->" ]

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

[ "class", "MVE_VADDSUBFMA_fp", "<", "string", "iname", ",", "string", "suffix", ",", "bit", "size", ",", "bit", "bit_4", ",", "bit", "bit_8", ",", "bit", "bit_21", ",", "dag", "iops", "=", "(", "ins", ")", ",", "vpred_ops", "vpred", "=", "vpred_r", ",", "string", "cstr", "=", "<STR_LIT>", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVEFloatArithNeon", "<", "iname", ",", "suffix", ",", "size", ",", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "!", "con", "(", "iops", ",", "(", "ins", "MQPR", ":", "$", "Qn", ",", "MQPR", ":", "$", "Qm", ")", ")", ",", "<STR_LIT>", ",", "vpred", ",", "cstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Qd", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";" ]

[ "setStackPointerRegisterToSaveRestore", "(", "Mips", "::", "SP", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOWI", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "EH_LABEL", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MEMBARRIER", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "if", "(", "Subtarget", "->", "isSingleFloat", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasSEInReg", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "}", "if", "(", "!", "Subtarget", "->", "hasBitCount", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasSwap", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";" ]

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

[ "def", "A2_paddif", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "Enc_e38e1f", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "{" ]

[ "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V4SF", "[", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VUPKLS_V4SF", ")", ")", "]", "<STR_LIT>" ]

[ "value", ";" ]

[ "{", "rtx", "op0", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "create_output_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op0", ",", "DImode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op1", ",", "V8DImode", ")", ";", "expand_insn", "(", "CODE_FOR_st64b", ",", "<NUM_LIT>", ",", "ops", ")", ";", "return", "const0_rtx", ";", "}", "case", "AARCH64_LS64_BUILTIN_ST64BV", ":", "{", "rtx", "op0", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "create_output_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "target", ",", "DImode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op0", ",", "DImode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op1", ",", "V8DImode", ")", ";", "expand_insn", "(", "CODE_FOR_st64bv", ",", "<NUM_LIT>", ",", "ops", ")", ";", "return", "ops", "[", "<NUM_LIT>", "]", ".", "value", ";", "}", "case", "AARCH64_LS64_BUILTIN_ST64BV0", ":", "{", "rtx", "op0", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "create_output_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "target", ",", "DImode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op0", ",", "DImode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "<NUM_LIT>", "]", ",", "op1", ",", "V8DImode", ")", ";", "expand_insn", "(", "CODE_FOR_st64bv0", ",", "<NUM_LIT>", ",", "ops", ")", ";", "return", "ops", "[", "<NUM_LIT>", "]", "." ]

[ "InsertDAGNode", "(", "DAG", ",", "N", ",", "NewMask", ")", ";" ]

[ "unsigned", "ShiftAmt", "=", "Shift", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShiftAmt", "!=", "<NUM_LIT>", "&&", "ShiftAmt", "!=", "<NUM_LIT>", "&&", "ShiftAmt", "!=", "<NUM_LIT>", ")", "return", "true", ";", "MVT", "VT", "=", "N", ".", "getSimpleValueType", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "NewMask", "=", "DAG", ".", "getConstant", "(", "Mask", ">>", "ShiftAmt", ",", "DL", ",", "VT", ")", ";", "SDValue", "NewAnd", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "X", ",", "NewMask", ")", ";", "SDValue", "NewShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "NewAnd", ",", "Shift", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

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

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

[ "}" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ ")", ";" ]

[ "rtl_opt_pass", "*", "make_pass_visium_reorg", "(", "gcc", "::", "context", "*", "ctxt", ")", "{", "return", "new", "pass_visium_reorg", "(", "ctxt" ]

[ ":", "<STR_LIT>", "b", "<STR_LIT>", "(", "_", "_", "A", ")", ":", "<STR_LIT>", "memory", "<STR_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_clflush", "(", "void", "const", "*", "_", "_", "A", ")", "{", "_", "_", "asm__", "(", "<STR_LIT>", "dcbf 0,%0", "<STR_LIT>", ":" ]

[ "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_bafaade3", ",", "TypeM", ">", ",", "Enc_a56825", "{" ]

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

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

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

[ "<STR_LIT>" ]

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

[ "break", ";" ]

[ "if", "(", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "false", ";", "if", "(", "mode", "==", "SFmode", ")", "{", "mode", "=", "DFmode", ";", "size", "=", "GET_MODE_SIZE", "(", "DFmode", ")", ";", "}", "constant_fp_to_128bit_vector", "(", "op", ",", "mode", ",", "<NUM_LIT>", ",", "info", ")", ";", "splat_p", "=", "true", ";", "break", ";", "}", "case", "CONST_VECTOR", ":", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "mode", "||", "GET_MODE_SIZE", "(", "mode", ")", "!=", "VECTOR_128BIT_BYTES", ")", "return", "false", ";", "machine_mode", "ele_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "size_t", "ele_size", "=", "GET_MODE_SIZE", "(", "ele_mode", ")", ";", "size_t", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "for", "(", "size_t", "num", "=", "<NUM_LIT>", ";", "num", "<", "nunits", ";", "num", "++", ")", "{", "rtx", "ele", "=", "CONST_VECTOR_ELT", "(", "op", ",", "num", ")", ";", "size_t", "byte_num", "=", "(", "BYTES_BIG_ENDIAN", "?", "num", ":", "nunits", "-", "<NUM_LIT>", "-", "num", ")", "*", "ele_size", ";", "if", "(", "CONST_INT_P", "(", "ele", ")", ")", "constant_int_to_128bit_vector", "(", "ele", ",", "ele_mode", ",", "byte_num", ",", "info", ")", ";", "else", "if", "(", "CONST_DOUBLE_P", "(", "ele", ")", ")", "constant_fp_to_128bit_vector", "(", "ele", ",", "ele_mode", ",", "byte_num", ",", "info", ")", ";", "else", "return", "false", ";", "}", "break", ";", "}", "case", "VEC_DUPLICATE", ":", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "mode", "||", "GET_MODE_SIZE", "(", "mode", ")", "!=", "VECTOR_128BIT_BYTES", ")", "return", "false", ";", "machine_mode", "ele_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "size_t", "ele_size", "=", "GET_MODE_SIZE", "(", "ele_mode", ")", ";", "rtx", "ele", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "size_t", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "ele", ")", "&&", "!", "CONST_DOUBLE_P", "(", "ele", ")", ")", "return", "false", ";", "for", "(", "size_t", "num", "=", "<NUM_LIT>", ";", "num", "<", "nunits", ";", "num", "++", ")", "{", "size_t", "byte_num", "=", "num", "*", "ele_size", ";", "if", "(", "CONST_INT_P", "(", "ele", ")", ")", "constant_int_to_128bit_vector", "(", "ele", ",", "ele_mode", ",", "byte_num", ",", "info", ")", ";", "else", "constant_fp_to_128bit_vector", "(", "ele", ",", "ele_mode", ",", "byte_num", ",", "info", ")", ";", "}", "break", ";", "}", "default", ":", "return", "false", ";", "}", "if", "(", "splat_p", "&&", "size", "<", "VECTOR_128BIT_BYTES", ")", "{", "if", "(", "(", "VECTOR_128BIT_BYTES", "%", "size", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "for", "(", "size_t", "offset", "=", "size", ";", "offset", "<", "VECTOR_128BIT_BYTES", ";", "offset", "+=", "size", ")", "memcpy", "(", "(", "void", "*", ")", "&", "info", "->", "bytes", "[", "offset", "]", ",", "(", "void", "*", ")", "&", "info", "->", "bytes", "[", "<NUM_LIT>", "]", ",", "size", ")", ";", "}", "info", "->", "or", "iginal_size", "=", "size", ";", "unsigned", "char", "first_byte", "=", "info", "->", "bytes", "[", "<NUM_LIT>", "]", ";", "info", "->", "all_bytes_same", "=", "true", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "VECTOR_128BIT_BYTES", ";", "i", "++", ")", "if", "(", "first_byte", "!=", "info", "->", "bytes", "[", "i", "]", ")", "{", "info", "->", "all_bytes_same", "=", "false", ";", "break", ";", "}", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "VECTOR_128BIT_HALF_WORDS", ";", "i", "++", ")", "info", "->", "half_words", "[", "i", "]", "=", "(", "(", "info", "->", "bytes", "[", "i", "*", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "info", "->", "bytes", "[", "(", "i", "*", "<NUM_LIT>", ")", "+", "<NUM_LIT>", "]", ")", ";", "unsigned", "short", "first_hword", "=", "info", "->", "half_words", "[", "<NUM_LIT>", "]", ";", "info", "->", "all_half_words_same", "=", "true", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "VECTOR_128BIT_HALF_WORDS", ";", "i", "++", ")", "if", "(", "first_hword", "!=", "info", "->", "half_words", "[", "i", "]", ")", "{", "info", "->", "all_half_words_same", "=", "false", ";" ]

[ "}" ]

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

[ ")", ";" ]

[ "void", "MSP430InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ")", "{", "printInstruction", "(", "MI" ]

[ ",", "Sched", "<", "[", "sched", ".", "Folded", ",", "ReadAfterLd", "]", ">", ";" ]

[ "def", "rm", ":", "PDI", "<", "opc", ",", "MRMSrcMem", ",", "(", "outs", "RC", ":", "$", "dst", ")", ",", "(", "ins", "RC", ":", "$", "src1", ",", "x86memop", ":", "$", "src2", ")", ",", "!", "if", "(", "Is2Addr", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ")", ",", "[", "(", "set", "RC", ":", "$", "dst", ",", "(", "OpVT", "(", "OpNode", "RC", ":", "$", "src1", ",", "(", "bitconvert", "(", "memop_frag", "addr", ":", "$", "src2", ")", ")", ")", ")", ")", "]", ">" ]

[ "void", "SparcFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Can only put epilog before 'retl' instruction!", "<STR_LIT>", ")", ";", "if", "(", "!", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "NumBytes", "==", "<NUM_LIT>", ")", "return", ";", "NumBytes", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}" ]

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

[ "}" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

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

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_paddb", "(", "_", "_", "m64", "_", "_", "m1", ",", "_", "_", "m64", "_", "_", "m2", ")", "{", "return", "_", "mm_add_pi8", "(", "_", "_", "m1", ",", "_", "_" ]

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

[ "union", "{", "poly16x4x2_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ti", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld2_dupv4hi", "(", "(", "const", "_", "_", "builtin_neon_hi", "*", ")", "_", "_" ]

[ "return", "true", ";" ]

[ "return", "false", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CCOpNo", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CCOpNo", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CCOpNo", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CCOpNo", "=", "<NUM_LIT>", ";", "break", ";", "}", "X86", "::", "CondCode", "CC", "=", "(", "X86", "::", "CondCode", ")", "User", "->", "getConstantOperandVal", "(", "CCOpNo", ")", ";", "if", "(", "CC", "!=", "X86", "::", "COND_E", "&&", "CC", "!=", "X86", "::", "COND_NE", ")", "return", "false", ";", "}" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ ",", "float16x4_t", "_", "_", "b", ")", "{" ]

[ "vfmlal_low_f16", "(", "float32x2_t", "_", "_", "r", ",", "float16x4_t", "_", "_", "a" ]

[ ")", "_", "mm_setzero_si128", "(", ")", ",", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vcvttph2uw128_mask", "(", "_", "_", "B", ",", "(", "_", "_", "v8hi" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VAXfp", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "VAXfp", "(", "match_operand", ":", "VAXfp", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VAXfp", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "VAX_PSL_REGNUM", ")", ")", "]" ]

[ "operands", ")" ]

[ "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_TLS_IE_SUN", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<STR_LIT>", "{", "output_asm_insn", "(", "<STR_LIT>", "," ]

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

[ "gcc_assert", "(", "superset", "==", "ADDR_SPACE_GENERIC", "||", "superset", "==", "ADDR_SPACE_EA", ")", ";", "if", "(", "subset", "==", "superset", ")", "return", "true", ";", "else", "if", "(", "!", "TARGET_ADDRESS_SPACE_CONVERSION", ")" ]

[ "}" ]

[ "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";" ]

[ "CPUSubtype", ")", ",", "OS", ",", "true", ")", ";" ]

[ "return", "createMachObjectWriter", "(", "new", "AArch64MachObjectWriter", "(", "CPUType", "," ]

[ "static", "bool", "mips_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", "&&", "!", "mips_signed_immediate_p", "(", "INTVAL", "(", "x", ")", ",", "<NUM_LIT>", ",", "mips_ldst_scaled_shift", "(", "mode", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";" ]

[ "SDValue", "M68kTargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "getJumpTableEncoding", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_Custom32", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(" ]

[ "<NUM_LIT>", ")", ",", "ComputePGMRSrc2", "(", "<NUM_LIT>", ")", ",", "NumVGPR", "(", "<NUM_LIT>", ")", ",", "NumSGPR", "(", "<NUM_LIT>", ")", ",", "FlatUsed", "(", "false", ")", ",", "VCCUsed", "(", "false", ")", ",", "CodeLen", "(", "<NUM_LIT>", ")", "{" ]

[ "VGPRBlocks", "(", "<NUM_LIT>", ")", ",", "SGPRBlocks", "(", "<NUM_LIT>", ")", ",", "Priority", "(", "<NUM_LIT>", ")", ",", "FloatMode", "(", "<NUM_LIT>", ")", ",", "Priv", "(", "<NUM_LIT>", ")", ",", "DX10Clamp", "(", "<NUM_LIT>", ")", ",", "DebugMode", "(", "<NUM_LIT>", ")", ",", "IEEEMode", "(", "<NUM_LIT>", ")", ",", "ScratchSize", "(", "<NUM_LIT>", ")", ",", "ComputePGMRSrc1", "(", "<NUM_LIT>", ")", ",", "LDSBlocks", "(", "<NUM_LIT>", ")", ",", "ScratchBlocks", "(" ]

[ "}" ]

[ "else", "if", "(", "!", "TARGET_NORMAL_MODE", ")", "x", "=", "gen_push_h8300hs_advanced", "(", "reg", ")", ";", "else", "x", "=", "gen_push_h8300hs_normal", "(", "reg", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "REG_NOTES", "(", "x", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "<NUM_LIT>", ")", ";" ]

[ "MachineDominatorTree", ">", "(", ")", ";" ]

[ "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "Base", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Base", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Base", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Offset", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Hint", ")", ")", ";" ]

[ "<FIXS>", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "<FIXE>" ]

[ "unsigned", "NewVAddrHi", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "<BUGS>", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "<BUGE>", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_I32_e32", ")", ",", "NewVAddrLo", ")", ".", "addReg", "(", "SRsrcPtr", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "VAddr", "->", "getReg", "(", ")", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub0", ")", ";" ]

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

[ "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "NewR", "=", "<NUM_LIT>", ";", "auto", "At", "=", "MI", "->", "isPHI", "(", ")", "?", "B", ".", "getFirstNonPHI", "(", ")", ":", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ";", "if", "(", "L", ".", "Low", "&&", "Opc", "!=", "Hexagon", "::", "A2_zxth", ")", "{", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "A2_zxth", ")", ",", "NewR", ")", ".", "addReg", "(", "L", ".", "Reg", ",", "<NUM_LIT>", ",", "L", ".", "Sub", ")", ";", "}", "else", "if", "(", "!", "L", ".", "Low", "&&", "Opc", "!=", "Hexagon", "::", "S2_lsr_i_r", ")", "{", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "S2_lsr_i_r", ")", ",", "NewR", ")", ".", "addReg", "(", "L", ".", "Reg", ",", "<NUM_LIT>", ",", "L", ".", "Sub", ")", "." ]

[ "}" ]

[ "vst1q_u32", "(", "uint32_t", "*", "a", ",", "uint32x4_t", "b", ")", "{", "_", "_", "builtin_aarch64_st1v4si", "(", "(", "_", "_", "builtin_aarch64_simd_si", "*", ")", "a", ",", "(", "int32x4_t", ")", "b", ")", ";" ]

[ "static", "unsigned", "getHashValue", "(", "const", "CvtDirection", "&", "Val", ")", "{", "return", "(", "Val", ".", "SourceType", "^", "Val", ".", "DestinationType", ")", "*", "<NUM_LIT>", "U", ";", "}" ]

[ "Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "." ]

[ ";" ]

[ "static", "unsigned", "getMopState", "(", "const", "MachineOperand", "&", "MO", ")", "{", "unsigned", "S", "=", "<NUM_LIT>", ";", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "S", "|=", "RegState", "::", "Implicit", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "S", "|=", "RegState", "::", "Dead", ";", "if", "(", "MO", ".", "isUndef", "(", ")", ")", "S", "|=", "RegState", "::", "Undef", ";", "if", "(", "MO", ".", "isKill", "(", ")", ")", "S", "|=", "RegState", "::", "Kill", ";", "if", "(", "MO", ".", "isEarlyClobber", "(", ")", ")", "S", "|=", "RegState", "::", "EarlyClobber", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", "&&", "MO", ".", "isRenamable", "(", ")", ")", "S", "|=", "RegState", "::", "Renamable", ";", "return", "S" ]

[ "if", "(", "RegNo", "<", "<NUM_LIT>", ")", "Reg", "=", "<STR_LIT>", "::", "<STR_LIT>", "+", "RegNo", ";" ]

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "Reg", ";" ]

[ "if", "(", "Subtarget", "->", "hasAnyDataBarrier", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";" ]

[ "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "getARMSubtarget", "(", ")", ";" ]

[ "<STR_LIT>" ]

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

[ ";" ]

[ "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Beginning BR iteration #", "<STR_LIT>", "<<", "NoBRIters", "<<", "'", "\\n", "'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Branch Fix Up pass failed to converge!", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "isThumb2", "&&", "!", "STI", "->", "prefers32BitThumb", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Instructions", "(", ")", ";", "if", "(", "isThumb", "&&", "STI", "->", "hasV8MBaselineOps", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Branches", "(", ")", ";", "if", "(", "GenerateTBB", "&&", "!", "STI", "->", "genExecuteOnly", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2JumpTables", "(", ")", ";", "verify", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPEntries", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "je", "=", "CPEntries", "[", "i", "]", ".", "size", "(", ")", ";", "j", "!=", "je", ";", "++", "j", ")", "{", "const", "CPEntry", "&", "CPE", "=", "CPEntries", "[", "i", "]", "[", "j", "]", ";", "if", "(", "CPE", ".", "CPEMI", "&&", "CPE", ".", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isCPI", "(", ")", ")", "AFI", "->", "recordCPEClone", "(", "i", ",", "CPE", ".", "CPI", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "\\n", "'", ";", "dumpBBs", "(", ")", ")", ";", "BBUtils", "->", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")" ]

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

[ "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V4SF", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

[ ")", ";" ]

[ "void", "SIMachineFunctionInfo", "::", "removeDeadFrameIndices", "(", "MachineFrameInfo", "&", "MFI", ")", "{", "for", "(", "auto", "&", "R", ":", "SGPRToVGPRSpills", ")", "{", "if", "(", "R", ".", "first", "!=", "FramePointerSaveIndex", ")", "MFI", ".", "RemoveStackObject", "(", "R", ".", "first" ]

[ "}" ]

[ "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

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

[ "TargetPassConfig", "*", "AVRTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "AVRPassConfig", "(", "*", "this" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Reg", ")", ")", ";" ]

[ "Reg", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Reg", ")", ";", "Base", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Base", ")", ";" ]

[ "?", "-", "<NUM_LIT>", "U", ":", "-", "<NUM_LIT>", "U", ";" ]

[ "if", "(", "STI", ".", "isDarwinABI", "(", ")", ")", "return", "STI", ".", "isPPC64", "(", ")" ]

[ ")", ";" ]

[ "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "return", "!", "MI", ".", "hasRegisterImplicitUseOperand", "(", "AMDGPU", "::", "M0" ]

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

[ "(", "lshiftrt", ":", "V2DI", "(", "plus", ":", "V2DI", "(", "mult", ":", "V2DI", "(", "zero_extend", ":", "V2DI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "V2DI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_vector", ":", "V2DI", "[", "(", "const_int", "<NUM_LIT>", ")" ]

[ ",", "Candidate", ".", "getNumOperands", "(", ")", ")", ";" ]

[ "HasHazard", "|=", "SawStore", ";", "SawLoad", "=", "true", ";", "}", "assert", "(", "(", "!", "Candidate", ".", "isCall", "(", ")", "&&", "!", "Candidate", ".", "isReturn", "(", ")", ")", "&&", "<STR_LIT>", "Cannot put calls or returns in delay slot.", "<STR_LIT>", ")", ";", "HasHazard", "|=", "RegDU", ".", "update", "(", "Candidate", ",", "<NUM_LIT>" ]

[ ")" ]

[ "(", "define_code_attr", "fetchop_opcode", "[", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")", "]", ")", "(", "define_code_attr", "fetchop_inops02", "[", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")", "]" ]

[ ")" ]

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

[ "bool", "XCoreAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "{", "return", "true", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "O", "<<", "'", "[", "'", ";", "printOperand", "(", "MI", ",", "OpNum", "+", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "]", "'", ";", "return", "false", ";", "}" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

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

[ "static", "void", "ReplaceATOMIC_LOAD", "(", "SDNode", "*", "Node", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "SDLoc", "dl", "(", "Node", ")", ";", "EVT", "VT", "=", "cast", "<", "AtomicSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "VT", ")", ";", "SDValue", "Swap", "=", "DAG", ".", "getAtomic", "(", "ISD", "::", "ATOMIC_CMP_SWAP", ",", "dl", ",", "VT", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Zero", ",", "Zero", ",", "cast", "<", "AtomicSDNode", ">", "(", "Node", ")", "->", "getMemOperand", "(", ")", ",", "cast", "<", "AtomicSDNode", ">", "(", "Node", ")", "->", "getOrdering", "(", ")", ",", "cast", "<", "AtomicSDNode", ">", "(", "Node", ")", "->", "getSynchScope", "(", ")", ")", ";", "Results", ".", "push_back", "(", "Swap", ".", "getValue", "(", "<NUM_LIT>" ]