Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "M", "%=", "Size", ";" ]

[ "int", "Size", "=", "Mask", ".", "size", "(", ")", ";", "int", "LaneSize", "=", "<NUM_LIT>", "/", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "const", "int", "NumBytes", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "const", "int", "NumEltBytes", "=", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "assert", "(", "(", "Subtarget", ".", "hasSSSE3", "(", ")", "&&", "VT", ".", "is128BitVector", "(", ")", ")", "||", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "VT", ".", "is256BitVector", "(", ")", ")", "||", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "VT", ".", "is512BitVector", "(", ")", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "PSHUFBMask", "(", "NumBytes", ")", ";", "SDValue", "ZeroMask", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "SDValue", "V", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "int", "M", "=", "Mask", "[", "i", "/", "NumEltBytes", "]", ";", "if", "(", "M", "<", "<NUM_LIT>", ")", "{", "PSHUFBMask", "[", "i", "]", "=", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i8", ")", ";", "continue", ";", "}", "if", "(", "Zeroable", "[", "i", "/", "NumEltBytes", "]", ")", "{", "PSHUFBMask", "[", "i", "]", "=", "ZeroMask", ";", "continue", ";", "}", "SDValue", "SrcV", "=", "(", "M", ">=", "Size", "?", "V2", ":", "V1", ")", ";", "if", "(", "V", "&&", "V", "!=", "SrcV", ")", "return", "SDValue", "(", ")", ";", "V", "=", "SrcV", ";" ]

[ ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>" ]

[ "&&", "size", ">", "<NUM_LIT>", "&&", "!", "SHCOMPACT_FORCE_ON_STACK", "(", "mode", ",", "type", ")", "&&", "!", "SH5_WOULD_BE_PARTIAL_NREGS", "(", "*", "cum", ",", "mode", ",", "type", ",", "named", ")", ")", "return", "size", ";" ]

[ "static", "int", "shcompact_byref", "(", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "cum", "->", "arg_count", "[", "SH_ARG_INT", "]", "<", "NPARM_REGS", "(", "SImode", ")", "&&", "(", "!", "named", "||", "GET_SH_ARG_CLASS", "(", "mode", ")", "==", "SH_ARG_INT", "||", "(", "GET_SH_ARG_CLASS", "(", "mode", ")", "==", "SH_ARG_FLOAT", "&&", "cum", "->", "arg_count", "[", "SH_ARG_FLOAT", "]", ">=", "NPARM_REGS", "(", "SFmode", ")", ")", ")" ]

[ ";" ]

[ "LastLoadedElt", "=", "i", ";", "}", "if", "(", "LastLoadedElt", "==", "NumElems", "-", "<NUM_LIT>", ")", "{", "assert", "(", "LDBase", "&&", "<STR_LIT>", "Did not find base load for merging consecutive loads", "<STR_LIT>", ")", ";", "EVT", "EltVT", "=", "LDBase", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "!=", "EltVT", ".", "getSizeInBits", "(", ")", "*", "NumElems", ")", "return", "SDValue", "(", ")", ";", "if", "(", "isAfterLegalize", "&&", "!", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isOperationLegal", "(", "ISD", "::", "LOAD", ",", "VT", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewLd", "=", "SDValue", "(", ")", ";", "NewLd", "=", "DAG", ".", "getLoad", "(", "VT", ",", "DL", ",", "LDBase", "->", "getChain", "(", ")", ",", "LDBase", "->", "getBasePtr", "(", ")", ",", "LDBase", "->", "getPointerInfo", "(", ")", ",", "LDBase", "->", "isVolatile", "(", ")", ",", "LDBase", "->", "isNonTemporal", "(", ")", ",", "LDBase", "->", "isInvariant", "(", ")", ",", "LDBase", "->", "getAlignment", "(", ")", ")", ";", "if", "(", "LDBase", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", "{", "SDValue", "NewChain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewLd", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "NewChain", ")", ";", "DAG", ".", "UpdateNodeOperands", "(", "NewChain", ".", "getNode", "(", ")", ",", "SDValue", "(", "LDBase", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewLd", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "}", "return", "NewLd" ]

[ "<STR_LIT>" ]

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

[ ")", ";" ]

[ "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "bool", "IsIntrinsic", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", ";", "SDValue", "LHS", "=", "N", "->", "getOperand", "(", "IsIntrinsic", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "IsIntrinsic", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "assert", "(", "LHS", ".", "getValueType", "(", ")", ".", "is64BitVector", "(", ")", "&&", "RHS", ".", "getValueType", "(", ")", ".", "is64BitVector", "(", ")", "&&", "<STR_LIT>", "unexpected shape for long operation", "<STR_LIT>", ")", ";", "if", "(", "isEssentiallyExtractSubvector", "(", "LHS", ")", ")", "{", "RHS", "=", "tryExtendDUPToExtractHigh", "(", "RHS", ",", "DAG", ")", ";", "if", "(", "!", "RHS", ".", "getNode", "(", ")", ")", "return", "SDValue", "(", ")", ";", "}", "else", "if", "(", "isEssentiallyExtractSubvector", "(", "RHS", ")", ")", "{", "LHS", "=", "tryExtendDUPToExtractHigh", "(", "LHS", ",", "DAG" ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ws", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "PostEncoderMethod", "=", "<STR_LIT>" ]

[ "MVT", "::", "i32", ",", "SizeC", ",", "Index", ")", ";" ]

[ "if", "(", "!", "isa", "<", "ConstantDataArray", ">", "(", "Init", ")", "||", "!", "Ty", "->", "getArrayElementType", "(", ")", "->", "isIntegerTy", "(", ")", "||", "Ty", "->", "getArrayElementType", "(", ")", "->", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getSizeInBits", "(", ")", "||", "Ty", "->", "getArrayNumElements", "(", ")", ">", "Ty", "->", "getArrayElementType", "(", ")", "->", "getScalarSizeInBits", "(", ")", ")", "continue", ";", "uint64_t", "ArrayElementCount", "=", "Init", "->", "getType", "(", ")", "->", "getArrayNumElements", "(", ")", ";", "bool", "ConstantsMatch", "=", "true", ";", "for", "(", "uint64_t", "j", "=", "<NUM_LIT>", ";", "j", "<", "ArrayElementCount", ";", "j", "++", ")", "{", "auto", "*", "Elem", "=", "cast", "<", "ConstantInt", ">", "(", "Init", "->", "getAggregateElement", "(", "j", ")", ")", ";", "if", "(", "Elem", "->", "getZExtValue", "(", ")", "!=", "(", "(", "(", "uint64_t", ")", "<NUM_LIT>", "<<", "j", ")", "-", "<NUM_LIT>", ")", ")", "{", "ConstantsMatch", "=", "false", ";", "break", ";", "}", "}", "if", "(", "!", "ConstantsMatch", ")", "continue", ";", "SDValue", "Inp", "=", "(", "i", "==", "<NUM_LIT>", ")", "?", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ":", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "SizeC", "=", "DAG", ".", "getConstant", "(", "VT", ".", "getSizeInBits", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Index", "=", "getIndexFromUnindexedLoad", "(", "Ld", ")", ";", "if", "(", "!", "Index", ")", "return", "SDValue", "(", ")", ";", "Index", "=", "DAG", ".", "getZExtOrTrunc", "(", "Index", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", "," ]

[ "case", "MipsABIInfo", "::", "ABI", "::", "N64", ":", "return", "<STR_LIT>", "abi64", "<STR_LIT>", ";" ]

[ "case", "MipsABIInfo", "::", "ABI", "::", "O32", ":", "return", "<STR_LIT>", "abi32", "<STR_LIT>", ";", "case", "MipsABIInfo", "::", "ABI", "::", "N32", ":", "return", "<STR_LIT>", "abiN32", "<STR_LIT>", ";" ]

[ "return", "FinishCall", "(", "CallConv", ",", "dl", ",", "isTailCall", ",", "isVarArg", ",", "isPatchPoint", ",", "false", ",", "DAG", ",", "RegsToPass", ",", "InFlag", ",", "Chain", ",", "CallSeqStart", ",", "Callee", ",", "SPDiff", ",", "NumBytes", ",", "Ins", ",", "InVals", ",", "CS", ")", ";" ]

[ "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", "||", "(", "isPPC64", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", ")", ")", "{", "unsigned", "ExtOp", "=", "Flags", ".", "isSExt", "(", ")", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ExtOp", ",", "dl", ",", "PtrVT", ",", "Arg", ")", ";", "}", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Passing structure by value is unimplemented!", "<STR_LIT>", ")", ";", "switch", "(", "Arg", ".", "getSimpleValueType", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected ValueType for argument!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Arg", ")", ")", ";", "else", "report_fatal_error", "(", "<STR_LIT>", "Handling of placing parameters on the stack is ", "<STR_LIT>", "<STR_LIT>", "unimplemented!", "<STR_LIT>", ")", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v1i128", ":", "case", "MVT", "::", "f128", ":", "case", "MVT", "::", "v4f64", ":", "case", "MVT", "::", "v4i1", ":", "report_fatal_error", "(", "<STR_LIT>", "Handling of this parameter type is unimplemented!", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "!", "isFunctionGlobalAddress", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Handling of indirect call is unimplemented!", "<STR_LIT>", ")", ";", "SDValue", "InFlag", ";", "for", "(", "auto", "Reg", ":", "RegsToPass", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Reg", ".", "first", ",", "Reg", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";" ]

[ "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "<NUM_LIT>", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";" ]

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

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

[ "<FIXS>", "mbb", "->", "getName", "(", ")", "+", "<STR_LIT>", "'!", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "report_fatal_error", "(", "<STR_LIT>", "Single-path code generation failed! ", "<STR_LIT>", "<STR_LIT>", "Could not find the PredicatedBlock of MBB: '", "<STR_LIT>", "+", "<BUGS>", "mbb", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getName", "(", ")", "+", "<STR_LIT>", "'!", "<STR_LIT>", ")", ";", "<BUGE>", "}", "std", "::", "vector", "PredicatedBlock", "*", ">", "getSubheaders", "(", ")" ]

[ "<FIXS>", "&&", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "||", "TARGET_POWERPC64", "||", "mode", "!=", "DFmode", ")", "<FIXE>" ]

[ "if", "(", "LEGITIMATE_OFFSET_ADDRESS_P", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "mode", "!=", "TImode", "<BUGS>", "&&", "(", "TARGET_HARD_FLOAT", "||", "TARGET_POWERPC64", "||", "mode", "!=", "DFmode", ")", "<BUGE>", "&&", "(", "TARGET_POWERPC64", "||", "mode", "!=", "DImode", ")", "&&", "LEGITIMATE_INDEXED_ADDRESS_P", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "<NUM_LIT>", ";" ]

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

[ "if", "(", "CallerCC", "!=", "CalleeCC", ")", "return", "false", ";", "if", "(", "CalleeCC", "!=", "CallingConv", "::", "Fast", "&&", "CalleeCC", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "if", "(", "std", "::", "any_of", "(", "Ins", ".", "begin", "(", ")", ",", "Ins", ".", "end", "(", ")", ",", "[", "]", "(", "const", "ISD", "::", "InputArg", "&", "IA", ")", "{", "return", "IA", ".", "Flags", ".", "isByVal", "(", ")", ";", "}", ")", ")", "return", "false", ";", "if", "(", "any_of", "(", "Outs", ",", "[", "]", "(", "const", "ISD", "::", "OutputArg", "&", "OA", ")", "{", "return", "OA", ".", "Flags", ".", "isByVal", "(", ")", ";", "}", ")", ")", "return", "false", ";", "if", "(", "!", "isFunctionGlobalAddress", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "return", "false", ";", "if", "(", "!", "resideInSameModule", "(", "Callee", ",", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ")", ")", "return", "false", ";", "if", "(", "CalleeCC", "==", "CallingConv", "::", "Fast", "&&", "TailCallOpt", ")", "return", "true", ";", "if", "(", "DisableSCO", ")", "return", "false", ";", "if", "(", "!", "hasSameArgumentList", "(", "MF", ".", "getFunction", "(", ")", ",", "CS", ")", "&&", "needStackSlotPassParameters", "(", "Subtarget", ",", "Outs", ")", ")", "{" ]

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

[ "rtx_insn", "*", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "far_jump_used", ")", "return", "true", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", "{", "cfun", "->", "machine", "->", "far_jump_used", "=", "<NUM_LIT>", ";", "return", "true", ";", "}" ]

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

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

[ "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "<NUM_LIT>", ",", "DL", ",", "F", ")", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "VRegs", "[", "Idx", "]", ")", ";", "unsigned", "Dst", "=", "VRegs", "[", "Idx", "]", ";", "bool", "Split", "=", "false", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "if", "(", "!", "Split", ")", "{", "Split", "=", "true", ";", "Dst", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildUndef", "(", "Dst", ")", ";", "}", "unsigned", "Tmp", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildInsert", "(", "Tmp", ",", "Dst", ",", "Reg", ",", "Offset", ")", ";", "Dst", "=", "Tmp", ";", "}", ")", ";", "if", "(", "Dst", "!=", "VRegs", "[", "Idx", "]", ")", "MIRBuilder", ".", "buildCopy", "(", "VRegs", "[", "Idx", "]", ",", "Dst", ")", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "CC_X86", ",", "DL", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ ",", "[", "SDNPMayLoad", ",", "SDNPMemOperand", "]", ">", ";" ]

[ "def", "PPCtoc_entry", ":", "SDNode", "<", "<STR_LIT>", ",", "SDTIntBinOp" ]

[ ";" ]

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

[ "(", "Dt", ",", "<STR_LIT>", ")", ",", "v8i16", ",", "v8i8", ",", "IntOp", ",", "ExtOp", ",", "Commutable", ">", ";" ]

[ "def", "v8i16", ":", "N3VLIntExt", "<", "op24", ",", "op23", ",", "<NUM_LIT>", ",", "op11_8", ",", "op4", ",", "itin", ",", "OpcodeStr", ",", "!", "strconcat" ]

[ "<NUM_LIT>", ";" ]

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

[ "Rx32", ";" ]

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

[ ")", ";" ]

[ "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "&&", "integer_zerop", "(", "array_type_nelts", "(", "type", ")", ")", ")", "||", "POINTER_TYPE_P", "(", "type", ")", ")", "{", "tree", "elem_type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "elem_type", ")", "==", "RECORD_TYPE", "&&", "lookup_attribute", "(", "<STR_LIT>", "sysv_abi va_list", "<STR_LIT>", ",", "TYPE_ATTRIBUTES", "(", "elem_type", ")", ")", ")", "return", "sysv_va_list_type_node", ";", "}", "return", "NULL_TREE", ";", "}", "return", "std_canonical_va_list_type", "(", "type" ]

[ "}" ]

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

[ "Value", "&&", "Value", "<=", "<NUM_LIT>", "ULL", ")", ")", ";" ]

[ "return", "(", "(", "Value", "<=", "<NUM_LIT>", "ULL", ")", "||", "(", "<NUM_LIT>", "ULL", "<=" ]

[ ";" ]

[ "unsigned", "getMinReservedArea", "(", ")", "const", "{", "return", "MinReservedArea" ]

[ "static", "bool", "sh_can_follow_jump", "(", "const", "rtx_insn", "*", "branch1", ",", "const", "rtx_insn", "*", "branch2", ")", "{", "if", "(", "TARGET_SH1", "&&", "flag_reorder_blocks_and_partition", "&&", "simplejump_p", "(", "branch2", ")", "&&", "CROSSING_JUMP_P", "(", "branch2", ")", ")", "return", "false", ";", "if", "(", "flag_expensive_optimizations", "&&", "simplejump_p", "(", "branch2", ")", ")", "{", "rtx", "dest", "=", "XEXP", "(", "SET_SRC", "(", "single_set", "(", "branch2", ")", ")", ",", "<NUM_LIT>", ")", ";", "rtx_insn", "*", "insn", ";", "int", "distance", ";", "for", "(", "distance", "=", "<NUM_LIT>", ",", "insn", "=", "NEXT_INSN", "(", "branch1", ")", ";", "insn", "&&", "distance", "<", "<NUM_LIT>", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "insn", "==", "dest", ")", "return", "true", ";", "else", "distance", "+=", "get_attr_length", "(", "insn", ")", ";", "}", "for", "(", "distance", "=", "<NUM_LIT>", ",", "insn", "=", "NEXT_INSN", "(", "branch1", ")", ";", "insn", "&&", "distance", "<", "<NUM_LIT>", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "insn", "==", "dest", ")", "return", "true", ";", "else", "distance", "+=", "get_attr_length", "(", "insn", ")", ";", "}", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "it", "'s", "possible", "to", "redirect", "BRANCH1", "to", "the", "destination", "of", "an", "unconditional", "jump", "BRANCH2", ".", "We", "only", "want", "to", "do", "this", "if", "the", "resulting", "branch", "will", "have", "a", "short", "displacement", "." ]

[ "}", ")" ]

[ "rtx", "scratch", "=", "gen_reg_rtx", "(", "V4SFmode", ")", "emit_insn", "(", "gen_aarch64_faddpv4sf", "(", "scratch", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_aarch64_faddpv4sf", "(", "scratch", ",", "scratch", ",", "scratch", ")", ")", "emit_insn", "(", "gen_aarch64_get_lanev4sf", "(", "operands", "[", "<NUM_LIT>", "]", ",", "scratch", ",", "elt", ")", ")", "DONE" ]

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

[ "return", "D", "(", "<STR_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm0_3Operand", ";", "let", "PrintMethod", "=" ]

[ "AddrMode_Imm12", "{" ]

[ "def", "addrmode_imm12", ":" ]

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

[ "(", "rotate", "<STR_LIT>", ")", "(", "smax", "<STR_LIT>", ")", "(", "smin", "<STR_LIT>", ")", "(", "umax", "<STR_LIT>", ")", "(", "umin", "<STR_LIT>", ")", "(", "ss_minus", "<STR_LIT>", ")", "(", "ss_plus", "<STR_LIT>", ")", "(", "us_minus", "<STR_LIT>", ")", "(", "us_plus", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")" ]

[ "_", "artificial__", ")", ")", "_", "m_pfsubr", "(", "_", "_", "m64", "_", "_", "A", ",", "_", "_", "m64", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_" ]

[ "::", "tGPRRegClass", ";" ]

[ "const", "TargetRegisterClass", "*", "Thumb1RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "ARM" ]

[ "=", "cond", ";" ]

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

[ "<STR_LIT>" ]

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

[ "}" ]

[ "bool", "cy", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "sy", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "VEValToCondCode", "(", "cf", ",", "isIntegerBCKind", "(", "MI", ")", ")", ")", ")", ";", "DecodeStatus", "status", ";", "if", "(", "cy", ")", "{", "status", "=", "DecodeI64RegisterClass", "(", "MI", ",", "sy", ",", "Address", ",", "Decoder", ")", ";", "if", "(", "status", "!=", "MCDisassembler", "::", "Success", ")", "return", "status", ";", "}", "else", "{", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "sy", ")", ")", ")", ";", "}", "return", "DecodeAS", "(", "MI", ",", "insn", ",", "Address", ",", "Decoder", ")", ";" ]

[ "auto", "Immed", "=", "getImmedFromMO", "(", "ShiftRHS", ")", ";" ]

[ "InstructionSelector", "::", "ComplexRendererFns", "AArch64InstructionSelector", "::", "selectShiftedRegister", "(", "MachineOperand", "&", "Root", ",", "bool", "AllowROR", ")", "const", "{", "if", "(", "!", "Root", ".", "isReg", "(", ")", ")", "return", "None", ";", "MachineRegisterInfo", "&", "MRI", "=", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "ShiftInst", "=", "MRI", ".", "getVRegDef", "(", "Root", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "ShiftInst", ")", "return", "None", ";", "<STR_LIT>", "::", "<STR_LIT>", "ShType", "=", "getShiftTypeForInst", "(", "*", "ShiftInst", ")", ";", "if", "(", "ShType", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "None", ";", "if", "(", "ShType", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "AllowROR", ")", "return", "None", ";", "if", "(", "!", "isWorthFoldingIntoExtendedReg", "(", "*", "ShiftInst", ",", "MRI", ")", ")", "return", "None", ";", "MachineOperand", "&", "ShiftRHS", "=", "ShiftInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

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

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

[ "(", "STRQro", "FPR128", ":", "$", "Rn", ",", "ro_indexed128", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "store", "(", "v16i8", "FPR128", ":", "$", "Rn", ")", ",", "ro_indexed128", ":", "$", "addr", ")", "," ]

[ "return", "&", "MBB", ";" ]

[ "MachineBasicBlock", "::", "iterator", "I", "(", "MI", ")", ";", "MachineInstrBuilder", "MIB", ";", "MachineOperand", "&", "Divisor", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "IsMicroMips", "?", "Mips", "::", "TEQ_MM", ":", "Mips", "::", "TEQ", ")", ")", ".", "addReg", "(", "Divisor", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "Divisor", ".", "isKill", "(", ")", ")", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "Is64Bit", ")", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setSubReg", "(", "Mips", "::", "sub_32", ")", ";", "Divisor", ".", "setIsKill", "(", "false", ")", ";" ]

[ "(", "INSERT_SUBREG", "(", "IMPLICIT_DEF", ")", ",", "V64", ":", "$", "Rd", ",", "dsub", ")", ",", "<NUM_LIT>", ",", "(", "INSERT_SUBREG", "(", "IMPLICIT_DEF", ")", ",", "V64", ":", "$", "Rn", ",", "dsub", ")", ",", "<NUM_LIT>", ")", ">", ";" ]

[ "class", "ConcatPat", "<", "ValueType", "DstTy", ",", "ValueType", "SrcTy", ">", ":", "Pat", "<", "(", "DstTy", "(", "concat_vectors", "(", "SrcTy", "V64", ":", "$", "Rd", ")", ",", "V64", ":", "$", "Rn", ")", ")", ",", "(", "INSvi64lane" ]

[ "static", "inline", "bool", "offset_12bit_unsigned_scaled_p", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "return", "(", "offset", ">=", "<NUM_LIT>", "&&", "offset", "<", "<NUM_LIT>", "*", "GET_MODE_SIZE", "(", "mode", ")", "&&", "offset", "%", "GET_MODE_SIZE", "(", "mode", ")", "==", "<NUM_LIT>", ")", ";", "}" ]

[ "Return", "true", "if", "OFFSET", "is", "an", "unsigned", "12-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";" ]

[ "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "local_cum", ".", "aapcs_nvrn", "==", "<NUM_LIT>", ")", ";", "vr_saved", "=", "<NUM_LIT>", ";", "}", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gr_saved", ">", "<NUM_LIT>", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "gr_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "aapcs_ncrn", "+", "R0_REGNUM", ",", "mem", ",", "gr_saved", ")", ";", "}", "if", "(", "vr_saved", ">", "<NUM_LIT>", ")", "{", "machine_mode", "mode", "=", "TImode", ";", "int", "off", ",", "i", ";", "off", "=", "-", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "off", "-=", "vr_saved", "*", "UNITS_PER_VREG", ";", "for", "(", "i", "=", "local_cum", ".", "aapcs_nvrn", ";", "i", "<", "NUM_FP_ARG_REGS", ";", "++", "i", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";" ]

[ "if", "(", "dw", "==", "MIN_DEP_WEAK", ")", "return", "param_sched_mem_true_dep_cost", ";" ]

[ "enum", "reg_note", "dep_type", "=", "(", "enum", "reg_note", ")", "dep_type1", ";", "enum", "attr_itanium_class", "dep_class", ";", "enum", "attr_itanium_class", "insn_class", ";", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "dep_class", "=", "ia64_safe_itanium_class", "(", "dep_insn", ")", ";", "if", "(", "dep_type", "==", "REG_DEP_TRUE", "&&", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "&&", "(", "insn_class", "==", "ITANIUM_CLASS_BR", "||", "insn_class", "==", "ITANIUM_CLASS_SCALL", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "}" ]

[ "SDValue", "SizeNode", "=", "DAG", ".", "getConstant", "(", "Size", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getMemcpy", "(", "Chain", ",", "dl", ",", "Dst", ",", "Src", ",", "SizeNode", ",", "Flags", ".", "getByValAlign", "(", ")", ",", "false", ",", "NULL", ",", "<NUM_LIT>", ",", "NULL", ",", "<NUM_LIT>", ")", ";" ]

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

[ "if", "(", "!", "printAlias", "(", "MI", ",", "OS", ")", "&&", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", "," ]

[ "::", "arm_neon_vld4", ":" ]

[ "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "PerformInsertEltCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "PerformVCVTCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "PerformVDIVCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "PerformSELECT_CCCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic" ]

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

[ "class", "FCAF_W_ENC", ":", "MSA_3RF_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

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

[ "def", "C2_cmovenewit", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "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", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

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

[ "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_shuf_f32x4_256_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B", ",", "_", "_", "imm", ",", "(", "_", "_", "v8sf", ")", "_", "_", "W", ",", "(" ]

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

[ "def", ":", "RWSysReg", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "}" ]

[ "bool", "isFlatOffset", "(", ")", "const", "{", "return", "isImmTy", "(", "ImmTyOffset", ")", "||", "isImmTy", "(", "ImmTyInstOffset", ")", ";" ]

[ "static", "void", "arm_print_value", "(", "FILE", "*", "f", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "{", "char", "fpstr", "[", "<NUM_LIT>", "]", ";", "real_to_decimal", "(", "fpstr", ",", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "sizeof", "(", "fpstr", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "fputs", "(", "fpstr", ",", "f", ")", ";", "}", "return", ";", "case", "CONST_VECTOR", ":", "{", "int", "i", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "<", "<STR_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "{", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", ")", ";", "if", "(", "i", "<", "(", "CONST_VECTOR_NUNITS", "(", "x", ")", "-", "<NUM_LIT>", ")", ")", "fputc", "(", "'", ",", "'", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "<STR_LIT>", ">", "<STR_LIT>", ")", ";", "}", "return", ";", "case", "CONST_STRING", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "\\\"%s\\\"", "<STR_LIT>", ",", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "`%s'", "<STR_LIT>", ",", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "L%d", "<STR_LIT>", ",", "INSN_UID", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "return", ";", "case", "CONST", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "PLUS", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "+", "<STR_LIT>", ")", ";", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "PC", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "pc", "<STR_LIT>", ")", ";", "return", ";", "default", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "????", "<STR_LIT>", ")", ";", "return", ";", "}", "}" ]

[ "Print", "a", "symbolic", "form", "of", "X", "to", "the", "debug", "file", ",", "F", "." ]

[ "<FIXS>", "let", "Predicates", "=", "[", "HasAVX", ",", "NoVLX", "]", "in", "{", "<FIXE>" ]

[ "(", "VBROADCASTF128", "addr", ":", "$", "src", ")", ">", ";", "}", "<BUGS>", "let", "Predicates", "=", "[", "HasAVX1Only", "]", "in", "{", "<BUGE>", "def", ":", "Pat", "(", "v4i64", "(", "X86SubVBroadcast", "(", "loadv2i64", "addr", ":", "$", "src", ")", ")", ")", ",", "(", "VBROADCASTF128", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v8i32", "(", "X86SubVBroadcast", "(", "loadv4i32", "addr", ":", "$", "src", ")", ")", ")", "," ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "}" ]

[ "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";" ]

[ "}", "]", ",", "logical_imm32_XFORM", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "}", "]", ">", ";", "def", "logical_imm64_XFORM", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "ARM64_AM", ":", ":", "encodeLogicalImmediate", "(", "N", "-", ">", "getZExtValue", "(", ")", ",", "<NUM_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "LogicalImm32Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "LogicalImm64Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "logical_imm32", ":", "Operand", "<", "i32", ">", ",", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "ARM64_AM", ":", ":", "isLogicalImmediate", "(", "N", "-", ">", "getZExtValue", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

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

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

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

[ "case", "ISD", "::", "XOR", ":", "return", "combineSelectAndUseCommutative", "(", "N", ",", "DCI", ",", "false", ")", ";", "case", "ISD", "::", "AND", ":", "return", "combineSelectAndUseCommutative", "(", "N", ",", "DCI", ",", "true", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue" ]

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

[ "return", "parseRegister", "(", "Operands", ",", "RegGR", ",", "<STR_LIT>" ]

[ ",", "node", ">", "{" ]

[ "def", "Wr", ":", "BaseOneOperandData", "<", "opc", ",", "GPR32", ",", "asm" ]

[ ",", "Ops", ",", "MemVT", ",", "M", "->", "getMemOperand", "(", ")", ")", ";" ]

[ "M", "->", "getMemOperand", "(", ")", "->", "setOffset", "(", "getBufferOffsetForMMO", "(", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ")", ")", ";", "EVT", "MemVT", "=", "VData", ".", "getValueType", "(", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "NewOpcode", ",", "DL", ",", "Op", "->", "getVTList", "(", ")" ]

[ ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

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

[ "(", "define_mode_attr", "VFMLA_SEL_W", "[", "(", "V2SF", "<STR_LIT>", ")", "(", "V4SF" ]

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

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

[ "static", "bool", "reg_plus_index_p", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "rtx", "xfoo0", ",", "xfoo1", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "false", ";", "xfoo0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "xfoo1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "BASE_REGISTER_P", "(", "xfoo0", ",", "strict", ")", "&&", "index_term_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "BASE_REGISTER_P", "(", "xfoo1", ",", "strict", ")", "&&", "index_term_p", "(", "xfoo0", ",", "mode", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "Return", "1", "if", "X", "is", "the", "sum", "of", "a", "register", "and", "a", "valid", "index", "term", "for", "mode", "MODE", "." ]

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

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "MMXMODEI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "MMXMODEI", "(", "match_operand", ":", "MMXMODEI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MMXMODEI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "return", "SubIdx", ";" ]

[ "assert", "(", "ElemWidth", ">=", "<NUM_LIT>", "&&", "ElemWidth", "<=", "<NUM_LIT>", ")", ";", "if", "(", "ElemWidth", "==", "<NUM_LIT>", ")", "return", "Idx", ";", "if", "(", "ty", "(", "Idx", ")", "!=", "MVT", "::", "i32", ")", "Idx", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "i32", ",", "Idx", ")", ";", "const", "SDLoc", "&", "dl", "(", "Idx", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "/", "ElemWidth", "-", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SubIdx", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i32", ",", "{", "Idx", ",", "Mask", "}", ")", ";" ]

[ "src", ",", "(", "i32", "<NUM_LIT>", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4f64", "(", "frint", "VR256", ":", "$", "src", ")", ")", ",", "(", "VROUNDPDYr", "VR256", ":", "$" ]

[ "}" ]

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

[ "}" ]

[ "class", "Enc_f5e933", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ps4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ps4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "DL", ")", ";" ]

[ "SDLoc", "DL", "(", "LoadNode", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "LoadNode", "->", "getPointerInfo", "(", ")", ";", "unsigned", "Alignment", "=", "LoadNode", "->", "getAlignment", "(", ")", ";", "MachineMemOperand", "*", "MemOp", "=", "LoadNode", "->", "getMemOperand", "(", ")", ";", "AAMDNodes", "AAInfo", "=", "LoadNode", "->", "getAAInfo", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getUNDEF", "(", "MemTy", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "<NUM_LIT>", ";", "++", "I", ")", "{", "if", "(", "I", ")", "{", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "Ptr", ".", "getValueType", "(", ")", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "SRF_REGISTER_LENGTH_IN_BYTES", ",", "DL", ",", "Ptr", ".", "getValueType", "(", ")", ")", ")", ";", "}", "SDValue", "V0", "=", "DAG", ".", "getLoad", "(", "EltTy", ",", "DL", ",", "Chain", ",", "Ptr", ",", "PtrInfo", ".", "getWithOffset", "(", "SRF_REGISTER_LENGTH_IN_BYTES", "*", "I", ")", ",", "Alignment", ",", "MemOp", "->", "getFlags", "(", ")", ",", "AAInfo", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "DL", ",", "MemTy", ",", "Result", ",", "V0", ",", "DAG", ".", "getConstant", "(", "I", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "SDValue", "Ops", "[", "<NUM_LIT>", "]", "=", "{", "Result", ",", "Chain", "}", ";" ]

[ "}" ]

[ "for", "(", "auto", "*", "DBI", ":", "DbgValues", ")", "{", "auto", "IndexType", "=", "DBI", "->", "isIndirectDebugValue", "(", ")", "?", "llvm", "::", "WebAssembly", "::", "TI_LOCAL_INDIRECT", ":", "llvm", "::", "WebAssembly", "::", "TI_LOCAL", ";", "for", "(", "auto", "&", "MO", ":", "DBI", "->", "getDebugOperandsForReg", "(", "CurrentReg", ")", ")", "MO", ".", "ChangeToTargetIndex", "(", "IndexType", ",", "LocalId", ")", ";", "}" ]

[ "}" ]

[ "inline", "vector", "signed", "short", "vec_vcmpequh", "(", "vector", "unsigned", "short", "a1", ",", "vector", "unsigned", "short", "a2", ")", "{", "return", "(", "vector", "signed", "short", ")", "_", "_", "builtin_altivec_vcmpequh", "(", "(", "vector", "signed", "short", ")", "a1", ",", "(", "vector", "signed", "short", ")", "a2", ")", ";" ]

[ ")", "{" ]

[ "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "CSI", ")" ]

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

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "]" ]

[ "}", "=", "rs", ";" ]

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

[ "Instruction", "*", "SPIRVEmitIntrinsics", "::", "visitInsertValueInst", "(", "InsertValueInst", "&", "I", ")", "{", "SmallVector", "<", "Type", "*", ",", "<NUM_LIT>", ">", "Types", "=", "{", "I", ".", "getInsertedValueOperand", "(", ")", "->", "getType", "(", ")", "}", ";", "SmallVector", "<", "Value", "*", ">", "Args", ";", "for", "(", "auto", "&", "Op", ":", "I", ".", "operands", "(", ")", ")", "if", "(", "isa", "<", "UndefValue", ">", "(", "Op", ")", ")", "Args", ".", "push_back", "(", "UndefValue", "::", "get", "(", "IRB", "->", "getInt32Ty", "(", ")", ")", ")", ";", "else", "Args", ".", "push_back", "(", "Op", ")", ";", "for", "(", "auto", "&", "Op", ":", "I", ".", "indices", "(", ")", ")", "Args", ".", "push_back", "(", "IRB", "->", "getInt32", "(", "Op", ")", ")", ";", "Instruction", "*", "NewI", "=", "IRB", "->", "CreateIntrinsic", "(", "Intrinsic", "::", "spv_insertv", ",", "{", "Types", "}", ",", "{", "Args", "}", ")", ";", "replaceMemInstrUses", "(", "&", "I", ",", "NewI", ")", ";", "return", "NewI", ";", "}" ]

[ "Try", "to", "find", "redundant", "insertvalue", "instructions", ",", "like", "the", "following", "ones", ":", "%", "0", "=", "insertvalue", "{", "i8", ",", "i32", "}", "undef", ",", "i8", "x", ",", "0", "%", "1", "=", "insertvalue", "{", "i8", ",", "i32", "}", "%", "0", ",", "i8", "y", ",", "0", "Here", "the", "second", "instruction", "inserts", "values", "at", "the", "same", "indices", ",", "as", "the", "first", "one", ",", "making", "the", "first", "one", "redundant", "." ]

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

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

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

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

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

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

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

[ "(", "zero_extend", ":", "AVX512ZEXTMASK", "(", "unspec", ":", "<", "VI1248_AVX512VLBW", ":", "avx512fmaskmode", ">", "[", "(", "match_operand", ":", "VI1248_AVX512VLBW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI1248_AVX512VLBW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ":" ]

[ "if", "(", "canCombineWithMUL", "(", "MBB", ",", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MULSUBW_OP2", ")", ";", "Found", "=", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "canCombineWithMUL", "(", "MBB", ",", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MULSUBX_OP1", ")", ";", "Found", "=", "true", ";", "}", "if", "(", "canCombineWithMUL", "(", "MBB", ",", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MULSUBX_OP2", ")", ";", "Found", "=", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "canCombineWithMUL", "(", "MBB", ",", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MULADDWI_OP1", ")", ";", "Found", "=", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "canCombineWithMUL", "(", "MBB", ",", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MULADDXI_OP1", ")", ";", "Found", "=", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "lane", ")", ",", "(", "MVE_VMOV_from_lane_u8", "MQPR", ":", "$", "src", ",", "imm", ":", "$", "lane", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "ARMvgetlaneu", "(", "v16i8", "MQPR", ":", "$", "src", ")", ",", "imm", ":", "$" ]

[ "}" ]

[ "unsigned", "EltSize", "=", "DL", ".", "getTypeSizeInBits", "(", "cast", "<", "VectorType", ">", "(", "ValTy", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "EltSize", "<", "<NUM_LIT>", ")", "{", "return", "BaseT", "::", "getVectorInstrCost", "(", "Opcode", ",", "ValTy", ",", "Index", ")", ";", "}", "return", "Index", "==", "~", "<NUM_LIT>", "u", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "default", ":", "return", "BaseT", "::", "getVectorInstrCost", "(", "Opcode", ",", "ValTy", ",", "Index", ")", ";" ]

[ "}" ]

[ "bool", "PPCRegisterInfo", "::", "hasBasePointer", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableBasePointer", ")", "return", "false", ";", "if", "(", "AlwaysBasePointer", ")", "return", "true", ";", "return", "hasStackRealignment", "(", "MF", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_fmsubadd_round_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ",", "_", "_", "m512d", "_", "_", "C", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmaddsubpd512_maskz", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "-", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "}" ]

[ "if", "(", "isX87Reg", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";" ]

[ "int", "rs6000_emit_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "rs6000_compare_op0", ";", "rtx", "op1", "=", "rs6000_compare_op1", ";", "REAL_VALUE_TYPE", "c1", ";", "enum", "machine_mode", "compare_mode", "=", "GET_MODE", "(", "op0", ")", ";", "enum", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "temp", ";", "bool", "is_against_zero", ";", "if", "(", "GET_MODE", "(", "op1", ")", "!=", "compare_mode", "&&", "(", "!", "TARGET_ISEL", "||", "!", "short_cint_operand", "(", "op1", ",", "VOIDmode", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_MODE", "(", "true_cond", ")", "!=", "result_mode", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_MODE", "(", "false_cond", ")", "!=", "result_mode", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "rs6000_compare_fp_p", ")", "{", "if", "(", "TARGET_ISEL", ")", "return", "rs6000_emit_int_cmove", "(", "dest", ",", "op", ",", "true_cond", ",", "false_cond", ")", ";", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "TARGET_E500", "&&", "TARGET_HARD_FLOAT", "&&", "!", "TARGET_FPRS", "&&", "GET_MODE_CLASS", "(", "compare_mode", ")", "==", "MODE_FLOAT", ")", "return", "<NUM_LIT>", ";", "is_against_zero", "=", "op1", "==", "CONST0_RTX", "(", "compare_mode", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "compare_mode", ")", "==", "MODE_FLOAT", "&&", "flag_trapping_math", "&&", "!", "is_against_zero", ")", "return", "<NUM_LIT>", ";", "if", "(", "code", "==", "UNLT", "||", "code", "==", "UNGT", "||", "code", "==", "UNORDERED", "||", "code", "==", "NE", "||", "code", "==", "LTGT", "||", "code", "==", "LT", "||", "code", "==", "UNLE", ")", "{", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "temp", "=", "true_cond", ";", "true_cond", "=", "false_cond", ";", "false_cond", "=", "temp", ";", "}", "if", "(", "code", "==", "UNEQ", "&&", "HONOR_NANS", "(", "compare_mode", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_DOUBLE", ")", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "c1", ",", "op1", ")", ";", "if", "(", "HONOR_INFINITIES", "(", "compare_mode", ")", "&&", "code", "!=", "GT", "&&", "code", "!=", "UNGE", "&&", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_DOUBLE", "||", "real_isinf", "(", "&", "c1", ")", ")", "&&", "(", "(", "!", "rtx_equal_p", "(", "op0", ",", "false_cond", ")", "&&", "!", "rtx_equal_p", "(", "op1", ",", "false_cond", ")", ")", "||", "(", "!", "rtx_equal_p", "(", "op0", ",", "true_cond", ")", "&&", "!", "rtx_equal_p", "(", "op1", ",", "true_cond", ")", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "is_against_zero", ")", "{", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_MINUS", "(", "compare_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "temp", ";", "op1", "=", "CONST0_RTX", "(", "compare_mode", ")", ";", "}", "if", "(", "!", "HONOR_NANS", "(", "compare_mode", ")", ")", "switch", "(", "code", ")", "{", "case", "GT", ":", "code", "=", "LE", ";", "temp", "=", "true_cond", ";", "true_cond", "=", "false_cond", ";", "false_cond", "=", "temp", ";", "break", ";", "case", "UNGE", ":", "code", "=", "GE", ";", "break", ";", "case", "UNEQ", ":", "code", "=", "EQ", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "code", ")", "{", "case", "GE", ":", "break", ";", "case", "LE", ":", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_NEG", "(", "compare_mode", ",", "op0", ")", ")", ")", ";", "op0", "=", "temp", ";", "break", ";", "case", "ORDERED", ":", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_ABS", "(", "compare_mode", ",", "op0", ")", ")", ")", ";", "op0", "=", "temp", ";", "break", ";", "case", "EQ", ":", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_NEG", "(", "compare_mode", ",", "gen_rtx_ABS", "(", "compare_mode", ",", "op0", ")", ")", ")", ")", ";", "op0", "=", "temp", ";", "break", ";", "case", "UNGE", ":", "temp", "=", "gen_reg_rtx", "(", "result_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "gen_rtx_GE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ",", "true_cond", ",", "false_cond", ")", ")", ")", ";", "false_cond", "=", "true_cond", ";", "true_cond", "=", "temp", ";", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_NEG", "(", "compare_mode", ",", "op0", ")", ")", ")", ";", "op0", "=", "temp", ";", "break", ";", "case", "GT", ":", "temp", "=", "gen_reg_rtx", "(", "result_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "gen_rtx_GE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ",", "true_cond", ",", "false_cond", ")", ")", ")", ";", "true_cond", "=", "false_cond", ";", "false_cond", "=", "temp", ";", "temp", "=", "gen_reg_rtx", "(", "compare_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_NEG", "(", "compare_mode", ",", "op0", ")", ")", ")", ";", "op0", "=", "temp", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "gen_rtx_GE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ",", "true_cond", ",", "false_cond", ")", ")", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Emit", "a", "conditional", "move", ":", "move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

[ "}" ]

[ "def", "movk_symbol_g3", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "MovKSymbolG3AsmOperand", ";" ]

[ ")", "{" ]

[ "vreinterpretq_s8_s16", "(", "int16x8_t", "_", "_", "a" ]

[ "&&", "(", "regno", "!=", "LR_REGNUM", ")", ";" ]

[ "int", "num_saves", "=", "XVECLEN", "(", "parallel_op", ",", "<NUM_LIT>", ")", ";", "if", "(", "TARGET_ARM", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_THUMB1", ")", "return", "<NUM_LIT>", ";", "regno", "=", "REGNO", "(", "first_op", ")", ";", "hi_reg", "=", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "HI_REGS", ")", "&&", "(", "regno", "!=", "LR_REGNUM", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_saves", "&&", "!", "hi_reg", ";", "i", "++", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "parallel_op", ",", "<NUM_LIT>", ",", "i", ")", ",", "<NUM_LIT>", ")", ")", ";", "hi_reg", "|=", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "HI_REGS", ")" ]

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

[ "(", "DI", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "V2SI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")", "(", "V8QI", "<STR_LIT>", ")" ]

[ "vect_num" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "reg", ":", "SI", "FPSCR_MODES_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")", "]", "<STR_LIT>", "{", "unsigned", "HOST_WIDE_INT" ]

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

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

[ "NumElems", "*", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "static", "bool", "isCommutedSHUFPMask", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "{", "int", "NumElems", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElems", "!=", "<NUM_LIT>", "&&", "NumElems", "!=", "<NUM_LIT>", ")", "return", "false", ";", "int", "Half", "=", "NumElems", "/", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "Half", ";", "++", "i", ")", "if", "(", "!", "isUndefOrInRange", "(", "Mask", "[", "i", "]", ",", "NumElems", "," ]

[ "<FIXS>", "warning", "(", "OPT_Wpragmas", ",", "<STR_LIT>", "junk at end of %<#pragma%> ghs interrupt", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "tree", "x", ";", "if", "(", "pragma_lex", "(", "&", "x", ")", "!=", "CPP_EOF", ")", "<BUGS>", "warning", "(", "OPT_Wpragmas", ",", "<STR_LIT>", "junk at end of #pragma ghs interrupt", "<STR_LIT>", ")", ";", "<BUGE>", "mark_current_function_as_interrupt", "(", ")", ";", "}" ]