Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ";" ]

[ "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "if", "(", "regno", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "microblaze_is_interrupt_variant", "(", ")", "||", "save_volatiles", ")", "&&", "(", "regno", ">=", "<NUM_LIT>", "&&", "regno", "<=", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_MSR_SAVE_REG", "||", "(", "interrupt_handler", "&&", "(", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", ")", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "save_volatiles", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", "return", "<NUM_LIT>", ";", "}", "return", "<NUM_LIT>" ]

[ ",", "_", "_", "m256i", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cvtepi16_epi8", "(", "_", "_", "m128i", "_", "_", "O", ",", "_", "_", "mmask16", "_", "_", "M" ]

[ "}" ]

[ "if", "(", "!", "Val", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Val", ")", ")", ";", "return", "MCDisassembler", "::", "Success", ";" ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "p1", "-", "isa", "(", "SLOTS", "P0S", ",", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpcmpge_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2SI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpcmpge", ".", "w", "crqp", ",", "crpp", "(", "p0_1", ")", "(", "dni", "cpcmpge_w_P0S_P1", "<STR_LIT>", "cpcmpge.w $crqp,$crpp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "p1", "-", "isa", "(", "SLOTS", "P0S", ",", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpcmpge_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2SI", ")", ")", "<BUGE>", "<STR_LIT>", "cpcmpge.w $crqp,$crpp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x12", ")", "crqp", "crpp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "x1d", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]

[ "}" ]

[ "unsigned", "char", "getPCAdjustment", "(", ")", "const", "{", "return", "PCAdjust", ";" ]

[ "unsigned", "int", "AArch64InstrInfo", "::", "getTailDuplicateSize", "(", "CodeGenOptLevel", "OptLevel", ")", "const", "{", "return", "OptLevel", ">=", "CodeGenOptLevel", "::", "Aggressive", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}" ]

[ "Returns", "the", "target-specific", "default", "value", "for", "tail", "duplication", "." ]

[ ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Xtensa", ")", ";", "SDValue", "Glue", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";", "unsigned", "Register", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Register", ",", "RetValue", ",", "Glue" ]

[ "unsigned", "Opc", ";" ]

[ "static", "SDValue", "LowerINT_TO_FP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "LowerVectorINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";" ]

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

[ "class", "BaseSIMDThreeScalar", "<", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteVd", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "match_operator", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", ")", ")", "]", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "fix", ":", "DI", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "POINTER_TYPE_P", "(", "type", ")", ")", "{" ]

[ "static", "machine_mode", "sparc_promote_function_mode", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "type", "!=", "NULL_TREE", "&&" ]

[ "<STR_LIT>", ")" ]

[ "(", "UNSPEC_SQRSHRUNT", "<STR_LIT>", ")", "(", "UNSPEC_SQSHL", "<STR_LIT>", ")", "(", "UNSPEC_SQSHLU", "<STR_LIT>", ")", "(", "UNSPEC_SQSHRNB", "<STR_LIT>", ")", "(", "UNSPEC_SQSHRNT", "<STR_LIT>", ")", "(", "UNSPEC_SQSHRUNB", "<STR_LIT>", ")", "(", "UNSPEC_SQSHRUNT", "<STR_LIT>", ")", "(", "UNSPEC_SQXTNB", "<STR_LIT>", ")", "(", "UNSPEC_SQXTNT", "<STR_LIT>", ")", "(", "UNSPEC_SQXTUNB", "<STR_LIT>", ")", "(", "UNSPEC_SQXTUNT", "<STR_LIT>", ")", "(", "UNSPEC_SRHADD", "<STR_LIT>", ")", "(", "UNSPEC_SRI", "<STR_LIT>", ")", "(", "UNSPEC_SRSHL", "<STR_LIT>", ")", "(", "UNSPEC_SRSHR", "<STR_LIT>", ")", "(", "UNSPEC_SSHLLB", "<STR_LIT>", ")", "(", "UNSPEC_SSHLLT", "<STR_LIT>", ")", "(", "UNSPEC_SSUBLB", "<STR_LIT>", ")", "(", "UNSPEC_SSUBLBT", "<STR_LIT>", ")", "(", "UNSPEC_SSUBLT", "<STR_LIT>", ")", "(", "UNSPEC_SSUBLTB", "<STR_LIT>", ")", "(", "UNSPEC_SSUBWB", "<STR_LIT>", ")", "(", "UNSPEC_SSUBWT", "<STR_LIT>", ")", "(", "UNSPEC_SUBHNB", "<STR_LIT>", ")", "(", "UNSPEC_SUBHNT", "<STR_LIT>", ")", "(", "UNSPEC_SUQADD", "<STR_LIT>", ")", "(", "UNSPEC_UABDLB", "<STR_LIT>", ")", "(", "UNSPEC_UABDLT", "<STR_LIT>", ")", "(", "UNSPEC_UADALP", "<STR_LIT>", ")", "(", "UNSPEC_UADDLB", "<STR_LIT>", ")", "(", "UNSPEC_UADDLT", "<STR_LIT>", ")", "(", "UNSPEC_UADDWB", "<STR_LIT>", ")", "(", "UNSPEC_UADDWT", "<STR_LIT>", ")", "(", "UNSPEC_UHADD", "<STR_LIT>", ")", "(", "UNSPEC_UHSUB", "<STR_LIT>", ")", "(", "UNSPEC_UMAXP", "<STR_LIT>", ")", "(", "UNSPEC_UMAXV", "<STR_LIT>", ")", "(", "UNSPEC_UMINP", "<STR_LIT>", ")", "(", "UNSPEC_UMINV", "<STR_LIT>", ")", "(", "UNSPEC_UMUL_HIGHPART", "<STR_LIT>", ")", "(", "UNSPEC_UMULLB", "<STR_LIT>", ")", "(", "UNSPEC_UMULLT", "<STR_LIT>", ")", "(", "UNSPEC_UQRSHL", "<STR_LIT>", ")", "(", "UNSPEC_UQRSHRNB", "<STR_LIT>", ")", "(", "UNSPEC_UQRSHRNT" ]

[ "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "DBGInstructions", ".", "push_back", "(", "&", "*", "I", ")", ";" ]

[ "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "DBGInstructions", ";", "for", "(", "auto", "I", "=", "First", "->", "getIterator", "(", ")", ",", "E", "=", "Last", "->", "getIterator", "(", ")", ";", "I", "!=", "E", ";", "I", "++", ")", "{" ]

[ "if", "(", "(", "DstVT", "==", "MVT", "::", "i16", "||", "DstVT", "==", "MVT", "::", "i32", ")", "&&", "(", "SrcVT", "==", "MVT", "::", "f16", "||", "SrcVT", "==", "MVT", "::", "bf16", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "SDLoc", "(", "N", ")", ",", "DstVT", ",", "MoveFromHPR", "(", "SDLoc", "(", "N", ")", ",", "DAG", ",", "MVT", "::", "i32", ",", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "Op", ")", ")", ";" ]

[ "EVT", "SrcVT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "SrcVT", "==", "MVT", "::", "i16", "||", "SrcVT", "==", "MVT", "::", "i32", ")", "&&", "(", "DstVT", "==", "MVT", "::", "f16", "||", "DstVT", "==", "MVT", "::", "bf16", ")", ")", "return", "MoveToHPR", "(", "SDLoc", "(", "N", ")", ",", "DAG", ",", "MVT", "::", "i32", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "Op", ")", ")", ";" ]

[ ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NewMIs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MBB", ".", "insert", "(", "MI", ",", "NewMIs", "[", "i", "]", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")" ]

[ "<STR_LIT>" ]

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

[ ")" ]

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

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

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

[ "<STR_LIT>", ")" ]

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

[ "}", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "MSA", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "addr", "=", "plus_constant", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "mips_emit_move", "(", "gen_rtx_MEM", "(", "<", "MODE", ">", "mode", ",", "addr", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

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

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

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

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

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

[ "addImmOperands", "(", "Inst" ]

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

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "R2", ";", "bits", "<", "<NUM_LIT>", ">", "I3", ";", "bits", "<", "<NUM_LIT>", ">", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I3", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "}", ";" ]

[ "Operands", "[", "<NUM_LIT>", "]", "=", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "movz", "<STR_LIT>", ",", "false", ",", "Loc", ",", "Ctx", ")", ";" ]

[ "uint64_t", "IntVal", "=", "RealVal", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "Mnemonic", "!=", "<STR_LIT>", "fcmp", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmpe", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmeq", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmge", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmgt", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmle", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmlt", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "fcmne", "<STR_LIT>", ")", "return", "TokError", "(", "<STR_LIT>", "unexpected floating point literal", "<STR_LIT>", ")", ";", "else", "if", "(", "IntVal", "!=", "<NUM_LIT>", "||", "isNegative", ")", "return", "TokError", "(", "<STR_LIT>", "expected floating-point constant #0.0", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "#0", "<STR_LIT>", ",", "false", ",", "S", ",", "getContext", "(", ")", ")", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", ".0", "<STR_LIT>", ",", "false", ",", "S", ",", "getContext", "(", ")", ")", ")", ";", "return", "false", ";", "}", "const", "MCExpr", "*", "ImmVal", ";", "if", "(", "parseSymbolicImmVal", "(", "ImmVal", ")", ")", "return", "true", ";", "E", "=", "SMLoc", "::", "getFromPointer", "(", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateImm", "(", "ImmVal", ",", "S", ",", "E", ",", "getContext", "(", ")", ")", ")", ";", "return", "false", ";", "}", "case", "AsmToken", "::", "Equal", ":", "{", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "if", "(", "Mnemonic", "!=", "<STR_LIT>", "ldr", "<STR_LIT>", ")", "return", "TokError", "(", "<STR_LIT>", "unexpected token in operand", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "MCExpr", "*", "SubExprVal", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "SubExprVal", ")", ")", "return", "true", ";", "if", "(", "Operands", ".", "size", "(", ")", "<", "<NUM_LIT>", "||", "!", "static_cast", "<", "AArch64Operand", "&", ">", "(", "*", "Operands", "[", "<NUM_LIT>", "]", ")", ".", "isScalarReg", "(", ")", ")", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "Only valid when first operand is register", "<STR_LIT>", ")", ";", "bool", "IsXReg", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ".", "contains", "(", "Operands", "[", "<NUM_LIT>", "]", "->", "getReg", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "getContext", "(", ")", ";", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Loc", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "isa", "<", "MCConstantExpr", ">", "(", "SubExprVal", ")", ")", "{", "uint64_t", "Imm", "=", "(", "cast", "<", "MCConstantExpr", ">", "(", "SubExprVal", ")", ")", "->", "getValue", "(", ")", ";", "uint32_t", "ShiftAmt", "=", "<NUM_LIT>", ",", "MaxShiftAmt", "=", "IsXReg", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "while", "(", "Imm", ">", "<NUM_LIT>", "&&", "countTrailingZeros", "(", "Imm", ")", ">=", "<NUM_LIT>", ")", "{", "ShiftAmt", "+=", "<NUM_LIT>", ";", "Imm", ">>=", "<NUM_LIT>", ";", "}", "if", "(", "ShiftAmt", "<=", "MaxShiftAmt", "&&", "Imm", "<=", "<NUM_LIT>", ")", "{" ]

[ "Changed", ";" ]

[ "if", "(", "Changed", ")", "F", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "return" ]

[ "(", "MII", "->", "getOperand", "(", "i", ")", ")", ";" ]

[ "case", "Hexagon", "::", "J2_loop1r", ":", "new", "Op", "=", "Hexagon", "::", "J2_loop1rext", ";", "break", ";", "case", "Hexagon", "::", "J2_loop1i", ":", "new", "Op", "=", "Hexagon", "::", "J2_loop1iext", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid Hardware Loop Instruction.", "<STR_LIT>", ")", ";", "}", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "DL", ",", "TII", "->", "get", "(", "new", "Op", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "MII", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "MIB", ".", "addOperand" ]

[ "FractVals", "[", "I", "]", "}", ")", ";" ]

[ "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "FractVals", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "ResultVals", "[", "I", "]", "=", "Builder", ".", "CreateIntrinsic", "(", "Intrinsic", "::", "amdgcn_fract", ",", "{", "Ty", "}", ",", "{" ]

[ "errs", "(", ")", "<<", "<STR_LIT>", "warning: the 'dsp' ASE requires MIPS64 revision 2 or ", "<STR_LIT>", "<<", "<STR_LIT>", "greater\\n", "<STR_LIT>", ";" ]

[ "if", "(", "hasMips64r6", "(", ")", "&&", "InMicroMipsMode", ")", "report_fatal_error", "(", "<STR_LIT>", "microMIPS64R6 is not supported", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "InMicroMipsMode", ")", "report_fatal_error", "(", "<STR_LIT>", "microMIPS64 is not supported.", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "UseIndirectJumpsHazard", ")", "{", "if", "(", "InMicroMipsMode", ")", "report_fatal_error", "(", "<STR_LIT>", "cannot combine indirect jumps with hazard barriers and microMIPS", "<STR_LIT>", ")", ";", "if", "(", "!", "hasMips32r2", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "indirect jumps with hazard barriers requires MIPS32R2 or later", "<STR_LIT>", ")", ";", "}", "if", "(", "inAbs2008Mode", "(", ")", "&&", "hasMips32", "(", ")", "&&", "!", "hasMips32r2", "(", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "IEEE 754-2008 abs.fmt is not supported for the given ", "<STR_LIT>", "<STR_LIT>", "architecture.", "<STR_LIT>", ",", "false", ")", ";", "}", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "<STR_LIT>", "MIPS64r6", "<STR_LIT>", ":", "<STR_LIT>", "MIPS32r6", "<STR_LIT>", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "assert", "(", "inAbs2008Mode", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "<STR_LIT>", " is not compatible with the DSP ASE", "<STR_LIT>", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "isPositionIndependent", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "position-independent code requires '-mabicalls'", "<STR_LIT>", ")", ";", "if", "(", "isABI_N64", "(", ")", "&&", "!", "TM", ".", "isPositionIndependent", "(", ")", "&&", "!", "hasSym32", "(", ")", ")", "NoABICalls", "=", "true", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "warning: cannot use small-data accesses for '-mabicalls'", "<STR_LIT>", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "UseSmallSection", "=", "false", ";", "}", "if", "(", "hasDSPR2", "(", ")", "&&", "!", "DspWarningPrinted", ")", "{", "if", "(", "hasMips64", "(", ")", "&&", "!", "hasMips64r2", "(", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "warning: the 'dspr2' ASE requires MIPS64 revision 2 or ", "<STR_LIT>", "<<", "<STR_LIT>", "greater\\n", "<STR_LIT>", ";", "DspWarningPrinted", "=", "true", ";", "}", "else", "if", "(", "hasMips32", "(", ")", "&&", "!", "hasMips32r2", "(", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "warning: the 'dspr2' ASE requires MIPS32 revision 2 or ", "<STR_LIT>", "<<", "<STR_LIT>", "greater\\n", "<STR_LIT>", ";", "DspWarningPrinted", "=", "true", ";", "}", "}", "else", "if", "(", "hasDSP", "(", ")", "&&", "!", "DspWarningPrinted", ")", "{", "if", "(", "hasMips64", "(", ")", "&&", "!", "hasMips64r2", "(", ")", ")", "{" ]

[ "<FIXS>", "VEX_4V", ",", "VEX_WIG", ";", "<FIXE>", "<FIXS>", "VEX_4V", ",", "VEX_WIG", ";", "<FIXE>", "<FIXS>", "VEX_4V", ",", "VEX_L", ",", "VEX_WIG", ";", "<FIXE>", "<FIXS>", "VEX_4V", ",", "VEX_L", ",", "VEX_WIG", ";", "<FIXE>" ]

[ "let", "Predicates", "=", "[", "HasAVX", ",", "NoVLX", "]", "in", "{", "defm", "VPMULLD", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "mul", ",", "v4i32", ",", "VR128", ",", "loadv2i64", ",", "i128mem", ",", "<NUM_LIT>", ",", "SSE_PMULLD_ITINS", ">", ",", "<BUGS>", "VEX_4V", ";", "<BUGE>", "defm", "VPCMPEQQ", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "X86pcmpeq", ",", "v2i64", ",", "VR128", ",", "loadv2i64", ",", "i128mem", ",", "<NUM_LIT>", ",", "SSE_INTALU_ITINS_P", ">", ",", "<BUGS>", "VEX_4V", ";", "<BUGE>", "}", "let", "Predicates", "=", "[", "HasAVX2", "]", "in", "{", "defm", "VPMULLDY", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "mul", ",", "v8i32", ",", "VR256", ",", "loadv4i64", ",", "i256mem", ",", "<NUM_LIT>", ",", "SSE_PMULLD_ITINS", ">", ",", "<BUGS>", "VEX_4V", ",", "VEX_L", ";", "<BUGE>", "defm", "VPCMPEQQY", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "X86pcmpeq", ",", "v4i64", ",", "VR256", ",", "loadv4i64", ",", "i256mem", ",", "<NUM_LIT>", ",", "SSE_INTALU_ITINS_P", ">", ",", "<BUGS>", "VEX_4V", ",", "VEX_L", ";", "<BUGE>", "}", "let", "Constraints", "=", "<STR_LIT>", "in", "{" ]

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

[ "void", "CFStack", "::", "popLoop" ]

[ "<STR_LIT>", ")" ]

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

[ ")", ")" ]

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "FB", "=", "Builder", ".", "CreateUnaryIntrinsic", "(", "Intrinsic", "::", "fabs", ",", "FB", ",", "FQ", ")", ";", "Value", "*", "CV", "=", "Builder", ".", "CreateFCmpOGE", "(", "FR", ",", "FB", ")", ";", "JQ", "=", "Builder", ".", "CreateSelect", "(", "CV", ",", "JQ", ",", "Builder", ".", "getInt32", "(", "<NUM_LIT>", ")", ")", ";", "Value", "*", "Div", "=", "Builder", ".", "CreateAdd", "(", "IQ", ",", "JQ", ")", ";", "Value", "*", "Res", "=", "Div", ";", "if", "(", "!", "IsDiv", ")", "{", "Value", "*", "Rem", "=", "Builder", ".", "CreateMul", "(", "Div", ",", "Den", ")", ";", "Res", "=", "Builder", ".", "CreateSub", "(", "Num", ",", "Rem", ")", ";", "}", "if", "(", "DivBits", "!=", "<NUM_LIT>", "&&", "DivBits", "<", "<NUM_LIT>", ")", "{", "if", "(", "IsSigned", ")", "{", "int", "InRegBits", "=", "<NUM_LIT>", "-", "DivBits", ";", "Res", "=", "Builder", ".", "CreateShl", "(", "Res", ",", "InRegBits", ")", ";", "Res", "=", "Builder", ".", "CreateAShr", "(", "Res", ",", "InRegBits", ")", ";", "}", "else", "{", "ConstantInt", "*", "TruncMask", "=", "Builder", ".", "getInt32", "(", "(", "UINT64_C", "(", "<NUM_LIT>", ")", "<<", "DivBits", ")", "-", "<NUM_LIT>", ")", ";", "Res", "=", "Builder", ".", "CreateAnd", "(", "Res", ",", "TruncMask", ")", ";", "}", "}", "return", "Res", ";" ]

[ "CONST", ":" ]

[ "if", "(", "!", "CONST_INT_P", "(", "x", ")", "||", "(", "n", "=", "exact_log2", "(", "INTVAL", "(", "x", ")", "&", "~", "<NUM_LIT>", ")", ")", "<=", "<NUM_LIT>", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "switch", "(", "n", ")", "{", "case", "<NUM_LIT>", ":", "fputc", "(", "'", "b", "'", ",", "f", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "fputc", "(", "'", "h", "'", ",", "f", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "fputc", "(", "'", "w", "'", ",", "f", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "}", "break", ";", "case", "'", "p", "'", ":", "{", "int", "n", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", "||", "(", "n", "=", "exact_log2", "(", "INTVAL", "(", "x", ")", ")", ")", "<", "<NUM_LIT>", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "n", ")", ";", "}", "break", ";", "case", "'", "P", "'", ":", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%u", "<STR_LIT>", ",", "popcount_hwi", "(", "INTVAL", "(", "x", ")", ")", ")", ";", "break", ";", "case", "'", "H", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "GP_REGNUM_P", "(", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "'", "M", "'", ":", "case", "'", "m", "'", ":", "{", "int", "cond_code", ";", "if", "(", "x", "==", "const_true_rtx", ")", "{", "if", "(", "code", "==", "'", "M", "'", ")", "fputs", "(", "<STR_LIT>", "nv", "<STR_LIT>", ",", "f", ")", ";", "return", ";", "}", "if", "(", "!", "COMPARISON_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "cond_code", "=", "aarch64_get_condition_code", "(", "x", ")", ";", "gcc_assert", "(", "cond_code", ">=", "<NUM_LIT>", ")", ";", "if", "(", "code", "==", "'", "M", "'", ")", "cond_code", "=", "AARCH64_INVERSE_CONDITION_CODE", "(", "cond_code", ")", ";", "fputs", "(", "aarch64_condition_codes", "[", "cond_code", "]", ",", "f", ")", ";", "}", "break", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "s", "'", ":", "case", "'", "d", "'", ":", "case", "'", "q", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%c%d", "<STR_LIT>", ",", "code", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", ")", ";", "break", ";", "case", "'", "S", "'", ":", "case", "'", "T", "'", ":", "case", "'", "U", "'", ":", "case", "'", "V", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "v%d", "<STR_LIT>", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", "+", "(", "code", "-", "'", "S", "'", ")", ")", ";", "break", ";", "case", "'", "R", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "q%d", "<STR_LIT>", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", "+", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "X", "'", ":", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "UINTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "w", "'", ":", "case", "'", "x", "'", ":", "if", "(", "x", "==", "const0_rtx", "||", "(", "CONST_DOUBLE_P", "(", "x", ")", "&&", "aarch64_float_const_zero_rtx_p", "(", "x", ")", ")", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%czr", "<STR_LIT>", ",", "code", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "GP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%c%d", "<STR_LIT>", ",", "code", ",", "REGNO", "(", "x", ")", "-", "R0_REGNUM", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "SP_REGNUM", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%ssp", "<STR_LIT>", ",", "code", "==", "'", "w", "'", "?", "<STR_LIT>", "w", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ";", "break", ";", "}", "case", "<NUM_LIT>", ":", "if", "(", "x", "==", "NULL", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "missing operand", "<STR_LIT>", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case" ]

[ ";" ]

[ "const", "SelectionDAGTargetInfo", "*", "getSelectionDAGInfo", "(", ")", "const", "override", "{", "return", "&", "TSInfo" ]

[ "let", "Pattern", "=", "pattern", ";" ]

[ "class", "XLForm_S", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "xo", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ",", "InstrItinClass", "itin", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "opcode", ",", "OOL", ",", "IOL", ",", "asmstr", ",", "itin", ">", "{", "bits", "<", "<NUM_LIT>", ">", "S", ";" ]

[ "return", "PerformADDCombineWithOperands", "(", "N", ",", "N1", ",", "N0", ",", "DCI", ",", "Subtarget", ")", ";" ]

[ "static", "SDValue", "PerformADDCombine", "(", "SDNode", "*", "N", ",", "TargetLowering", "::", "DAGCombinerInfo", "&", "DCI", ",", "const", "ARMSubtarget", "*", "Subtarget", ")", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "SDValue", "Result", "=", "PerformSHLSimplify", "(", "N", ",", "DCI", ",", "Subtarget", ")", ")", "return", "Result", ";", "if", "(", "SDValue", "Result", "=", "PerformADDVecReduce", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ")", "return", "Result", ";", "if", "(", "SDValue", "Result", "=", "PerformADDCombineWithOperands", "(", "N", ",", "N0", ",", "N1", ",", "DCI", ",", "Subtarget", ")", ")", "return", "Result", ";" ]

[ "return", "spoiled", ";" ]

[ "unsigned", "brother", "=", "hwloops", "[", "rooti", "]", ".", "RightLoop", ";", "spoiled", "|=", "IsLoopTreeSpoiled", "(", "elderson", ")", ";", "spoiled", "|=", "IsLoopTreeSpoiled", "(", "brother", ")", ";" ]

[ ")", ")" ]

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

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

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

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

[ "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "float_truncate", ":", "SF", "<BUGS>", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{", "switch", "(", "which_alternative", ")" ]

[ "}" ]

[ "static", "unsigned", "getScratchScaleFactor", "(", "const", "GCNSubtarget", "&", "ST", ")", "{", "return", "ST", ".", "enableFlatScratch", "(", ")", "?", "<NUM_LIT>", ":", "ST", ".", "getWavefrontSize", "(", ")", ";" ]

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

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

[ ";" ]

[ "CCValAssign", "&", "VA", "=", "ValLocs", "[", "<NUM_LIT>", "]", ";", "const", "Value", "*", "RV", "=", "Ret", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "&&", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "BCvt", ")", ")", "return", "false", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "RV", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "Reg", "+", "VA", ".", "getValNo", "(", ")", ";", "unsigned", "DestReg", "=", "VA", ".", "getLocReg", "(", ")", ";", "if", "(", "!", "MRI", ".", "getRegClass", "(", "SrcReg", ")", "->", "contains", "(", "DestReg", ")", ")", "return", "false", ";", "EVT", "RVEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "RV", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "RVEVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "RVEVT", ".", "isVector", "(", ")", ")", "return", "false", ";", "MVT", "RVVT", "=", "RVEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "RVVT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "MVT", "DestVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "RVVT", "!=", "DestVT", ")", "{", "if", "(", "RVVT", "!=", "MVT", "::", "i1", "&&", "RVVT", "!=", "MVT", "::", "i8", "&&", "RVVT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "if", "(", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "||", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "{", "bool", "IsZExt", "=", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", ";", "SrcReg", "=", "emitIntExt", "(", "RVVT", ",", "SrcReg", ",", "DestVT", ",", "IsZExt", ")", ";", "if", "(", "SrcReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "}", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "RetRegs", ".", "push_back", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "emitInst", "(", "Mips", "::", "RetRA", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RetRegs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addReg", "(", "RetRegs", "[", "i", "]", ",", "RegState", "::", "Implicit", ")", ";", "return", "true" ]

[ "void", "ARMBaseRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "unsigned", "i", "=", "<NUM_LIT>", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "static_cast", "<", "const", "ARMFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "<STR_LIT>", "This eliminateFrameIndex does not support Thumb1!", "<STR_LIT>", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "Instr doesn't have FrameIndex operand!", "<STR_LIT>", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "TFI", "->", "ResolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "SPAdj", ")", ";", "if", "(", "RS", "&&", "FrameReg", "==", "ARM", "::", "SP", "&&", "FrameIndex", "==", "RS", "->", "getScavengingFrameIndex", "(", ")", ")", "{", "assert", "(", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions without a reserved call frame", "<STR_LIT>", ")", ";", "assert", "(", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions with variable sized frame objects", "<STR_LIT>", ")", ";", "}", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "}", "if", "(", "Done", ")", "return", ";", "assert", "(", "(", "Offset", "||", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "<STR_LIT>", "This code isn't needed if offset already handled!", "<STR_LIT>", ")", ";", "unsigned", "ScratchReg", "=", "<NUM_LIT>", ";", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "Pred", "=", "(", "PIdx", "==", "-", "<NUM_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "MI", ".", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "PredReg", "=", "(", "PIdx", "==", "-", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "MI", ".", "getOperand", "(", "PIdx", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "false", ")", ";", "else", "{", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "ARM", "::", "GPRRegisterClass", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "emitARMRegPlusImmediate", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "emitT2RegPlusImmediate", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "Pred", ",", "PredReg", ",", "TII", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "InvokeWrappers", "[", "Sig", "]", "=", "F", ";" ]

[ "auto", "*", "CalleeTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Callee", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "CalleeFTy", "=", "dyn_cast", "<", "FunctionType", ">", "(", "CalleeTy", ")", ";", "}", "std", "::", "string", "Sig", "=", "getSignature", "(", "CalleeFTy", ")", ";", "if", "(", "InvokeWrappers", ".", "find", "(", "Sig", ")", "!=", "InvokeWrappers", ".", "end", "(", ")", ")", "return", "InvokeWrappers", "[", "Sig", "]", ";", "ArgTys", ".", "push_back", "(", "PointerType", "::", "getUnqual", "(", "CalleeFTy", ")", ")", ";", "ArgTys", ".", "append", "(", "CalleeFTy", "->", "param_begin", "(", ")", ",", "CalleeFTy", "->", "param_end", "(", ")", ")", ";", "FunctionType", "*", "FTy", "=", "FunctionType", "::", "get", "(", "CalleeFTy", "->", "getReturnType", "(", ")", ",", "ArgTys", ",", "CalleeFTy", "->", "isVarArg", "(", ")", ")", ";", "Function", "*", "F", "=", "Function", "::", "Create", "(", "FTy", ",", "GlobalValue", "::", "ExternalLinkage", ",", "InvokePrefix", "+", "Sig", ",", "&", "M", ")", ";" ]

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

[ "def", "J2_ploop1si", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "b30_2Imm", ":", "$", "Ii", ",", "u10_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_1c4528a2", ",", "TypeCR", ">", ",", "Enc_4dc228", "{", "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", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "if", "(", "TARGET_MACHO", "&&", "!", "TARGET_64BIT", ")", "{", "if", "(", "reg", "==", "<NUM_LIT>", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "return", "machopic_legitimize_pic_address", "(", "or", "ig", ",", "GET_MODE", "(", "or", "ig", ")", ",", "reg", ")", ";", "}", "<FIXE>" ]

[ "rtx", "base", ";", "#", "if", "TARGET_MACHO", "<BUGS>", "if", "(", "reg", "==", "<NUM_LIT>", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "return", "machopic_legitimize_pic_address", "(", "or", "ig", ",", "GET_MODE", "(", "or", "ig", ")", ",", "reg", ")", ";", "<BUGE>", "#", "endifif", "(", "TARGET_64BIT", "&&", "legitimate_pic_address_disp_p", "(", "addr", ")", ")" ]

[ "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "<NUM_LIT>", ",", "<STR_LIT>", "lo", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", ";", "Function", "*", "IntCmpXchg", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "ppc_cmpxchg_i128", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "CmpLo", "=", "Builder", ".", "CreateTrunc", "(", "CmpVal", ",", "Int64Ty", ",", "<STR_LIT>", "cmp_lo", "<STR_LIT>", ")", ";", "Value", "*", "CmpHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "CmpVal", ",", "<NUM_LIT>", ")", ",", "Int64Ty", ",", "<STR_LIT>", "cmp_hi", "<STR_LIT>", ")", ";", "Value", "*", "NewLo", "=", "Builder", ".", "CreateTrunc", "(", "NewVal", ",", "Int64Ty", ",", "<STR_LIT>", "new_lo", "<STR_LIT>", ")", ";", "Value", "*", "NewHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "NewVal", ",", "<NUM_LIT>", ")", ",", "Int64Ty", ",", "<STR_LIT>", "new_hi", "<STR_LIT>", ")", ";", "Value", "*", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "AlignedAddr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "emitLeadingFence", "(", "Builder", ",", "CI", ",", "Ord", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "IntCmpXchg", ",", "{", "Addr", ",", "CmpLo", ",", "CmpHi", ",", "NewLo", ",", "NewHi", "}", ")", ";", "emitTrailingFence", "(", "Builder", ",", "CI", ",", "Ord", ")", ";" ]

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

[ "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getMaybeAlignValue", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "arm_neon_vld1x2", ":", "case", "Intrinsic", "::", "arm_neon_vld1x3", ":", "case", "Intrinsic", "::", "arm_neon_vld1x4", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "auto", "&", "DL", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "uint64_t", "NumElts", "=", "DL", ".", "getTypeSizeInBits", "(", "I", ".", "getType", "(", ")", ")", "/", "<NUM_LIT>", ";", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "auto", "&", "DL", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "NumElts", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "ArgI", "=", "<NUM_LIT>", ",", "ArgE", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "ArgI", "<", "ArgE", ";", "++", "ArgI", ")", "{", "Type", "*", "ArgTy", "=", "I", ".", "getArgOperand", "(", "ArgI", ")", "->", "getType", "(", ")", ";", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "break", ";", "NumElts", "+=", "DL", ".", "getTypeSizeInBits", "(", "ArgTy", ")", "/", "<NUM_LIT>", ";", "}", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getMaybeAlignValue", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOStore", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "arm_neon_vst1x2", ":", "case", "Intrinsic", "::", "arm_neon_vst1x3", ":", "case", "Intrinsic", "::", "arm_neon_vst1x4", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "auto", "&", "DL", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "NumElts", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "ArgI", "=", "<NUM_LIT>", ",", "ArgE", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "ArgI", "<", "ArgE", ";", "++", "ArgI", ")", "{", "Type", "*", "ArgTy", "=", "I", ".", "getArgOperand", "(", "ArgI", ")", "->", "getType", "(", ")", ";", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "break", ";", "NumElts", "+=", "DL", ".", "getTypeSizeInBits", "(", "ArgTy", ")", "/", "<NUM_LIT>", ";", "}", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Info", ".", "align", ".", "reset", "(", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOStore", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "arm_mve_vld2q", ":", "case", "Intrinsic", "::", "arm_mve_vld4q", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Type", "*", "VecTy", "=", "cast", "<", "StructType", ">", "(", "I", ".", "getType", "(", ")", ")", "->", "getElementType", "(", "<NUM_LIT>", ")", ";", "unsigned", "Factor", "=", "Intrinsic", "==", "Intrinsic", "::", "arm_mve_vld2q", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "VecTy", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "Factor", "*", "<NUM_LIT>", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Info", ".", "align", "=", "Align", "(", "VecTy", "->", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";" ]

[ ")", "{" ]

[ "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "<NUM_LIT>", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "true", ";", "if", "(", "SoftFloat", ")", "{", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "<STR_LIT>", "+soft-float", "<STR_LIT>", ":", "<STR_LIT>", ",+soft-float", "<STR_LIT>", ";", "}", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I" ]

[ ".", "getNode", "(", ")", ")", ")", ")", "return", "false", ";" ]

[ "if", "(", "allUsesHaveSourceMods", "(", "N", ",", "<NUM_LIT>", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "fnegFoldsIntoOp", "(", "N0", ".", "getNode", "(", ")", ")", "&&", "(", "allUsesHaveSourceMods", "(", "N", ")", "||", "!", "allUsesHaveSourceMods", "(", "N0" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "not", ":", "QI", "(", "any_shiftrt", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "zero_extract", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "not", ":", "QI", "(", "any_shiftrt", ":", "QI" ]

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

[ "vorr_s8", "(", "int8x8_t", "_", "_", "a", ",", "int8x8_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "|" ]

[ "<FIXS>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "plus", ":", "QI", "(", "subreg", ":", "QI", "(", "match_op_dup", "<NUM_LIT>", "<BUGS>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

[ "false", ";" ]

[ "else", "if", "(", "LoadSDNode", "*", "LN", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "if", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "!", "isa", "<", "ConstantPoolSDNode", ">", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "ConstantPoolSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "LN", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FVal", "=", "cast", "<", "ConstantFP", ">", "(", "CN", "->", "getConstVal", "(", ")", ")", "->", "getValueAPF", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "IsExact", ";", "if", "(", "isReciprocal", ")", "if", "(", "!", "FVal", ".", "getExactInverse", "(", "&", "FVal", ")", ")", "return", "false", ";", "APSInt", "IntVal", "(", "<NUM_LIT>", ",", "true", ")", ";", "FVal", ".", "convertToInteger", "(", "IntVal", ",", "APFloat", "::", "rmTowardZero", ",", "&", "IsExact", ")", ";", "if", "(", "!", "IsExact", "||", "!", "IntVal", ".", "isPowerOf2", "(", ")", ")", "return" ]

[ ":" ]

[ "}", "case", "ARM", "::", "STRD", ":", "{", "unsigned", "Rm", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Rm", ")", "return", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "case", "ARM", "::", "LDRD_POST", ":", "case", "ARM", "::", "t2LDRD_POST", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "STRD_POST", ":", "case", "ARM", "::", "t2STRD_POST", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "LDRD_PRE", ":", "{", "unsigned", "Rt", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Rn", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Rm", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Rm", ")", "return", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "(", "Rt", "==", "Rn", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "case", "ARM", "::", "t2LDRD_PRE", ":", "{", "unsigned", "Rt", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Rn", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "(", "Rt", "==", "Rn", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "case", "ARM", "::", "STRD_PRE", ":", "{", "unsigned", "Rm", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Rm", ")", "return", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "case", "ARM", "::", "t2STRD_PRE", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "t2LDR_POST", ":", "case", "ARM", "::", "t2LDRB_POST", ":", "case", "ARM", "::", "t2LDRB_PRE", ":", "case", "ARM", "::", "t2LDRSBi12", ":", "case", "ARM", "::", "t2LDRSBi8", ":", "case", "ARM", "::", "t2LDRSBpci", ":", "case", "ARM", "::", "t2LDRSBs", ":", "case", "ARM", "::", "t2LDRH_POST", ":", "case", "ARM", "::", "t2LDRH_PRE", ":", "case", "ARM", "::", "t2LDRSBT", ":", "case", "ARM", "::", "t2LDRSB_POST", ":", "case", "ARM", "::", "t2LDRSB_PRE", ":", "case", "ARM", "::", "t2LDRSH_POST", ":", "case", "ARM", "::", "t2LDRSH_PRE", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRSHpci", ":", "case", "ARM", "::", "t2LDRSHs", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "t2LDRDi8", ":", "{", "unsigned", "Rt", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Rn", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "(", "Rt", "==", "Rn", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "case", "ARM", "::", "t2STRB_POST", ":", "case", "ARM", "::", "t2STRB_PRE", ":", "case", "ARM", "::", "t2STRBs", ":", "case", "ARM", "::", "t2STRDi8", ":", "case", "ARM", "::", "t2STRH_POST", ":", "case", "ARM", "::", "t2STRH_PRE", ":", "case", "ARM", "::", "t2STRHs", ":", "case", "ARM", "::", "t2STR_POST", ":", "case", "ARM", "::", "t2STR_PRE", ":", "case", "ARM", "::", "t2STRs" ]

[ "}" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<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>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "def", "simm7s16", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "SImm7s16Operand", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "if", "(", "Op", "!=", "ISD", "::", "SMAX", "&&", "Op", "!=", "ISD", "::", "UMAX", "&&", "Op", "!=", "ISD", "::", "SMIN", "&&", "Op", "!=", "ISD", "::", "UMIN", ")", "return", "SDValue", "(", ")", ";" ]

[ "static", "SDValue", "performAcrossLaneMinMaxReductionCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "const", "AArch64Subtarget", "*", "Subtarget", ")", "{", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "IfTrue", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "IfFalse", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", "||", "IfTrue", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", "||", "IfFalse", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "SDValue", "(", ")", ";", "SDValue", "SetCC", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SetCCVT", "=", "SetCC", ".", "getValueType", "(", ")", ";", "if", "(", "SetCC", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SETCC", "||", "!", "SetCCVT", ".", "isVector", "(", ")", "||", "SetCCVT", ".", "getVectorElementType", "(", ")", "!=", "MVT", "::", "i1", ")", "return", "SDValue", "(", ")", ";", "SDValue", "VectorOp", "=", "SetCC", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Op", "=", "VectorOp", "->", "getOpcode", "(", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "operands", "[", "<NUM_LIT>", "]", "!", "=", "const0_rtx", ")" ]

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

[ ">", "(", "NAME", "#", "<STR_LIT>", ")", ",", "GPR32", ",", "VectorIndexS", ">", ";" ]

[ "def", ":", "SIMDMovAlias", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "!", "cast", "<", "Instruction" ]

[ "}" ]

[ "bool", "AArch64IndirectThunks", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "initTIs", "(", "M", ",", "TIs", ")", ";", "return", "false", ";" ]

[ "let", "ParserMatchClass", "=", "SImm4s4Operand", ";" ]

[ "def", "simm4s4", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "Imm", ">", "=", "-", "<NUM_LIT>", "&", "&", "Imm", "<", "=", "<NUM_LIT>", "&", "&", "(", "Imm", "%", "<NUM_LIT>", ")", "=", "=", "<NUM_LIT>", ";", "}", "]", ",", "SImmS4XForm", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "static_cast", "<", "uint8_t", ">", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";" ]

[ "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";" ]

[ "}" ]

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

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";" ]

[ "assert", "(", "ARM", ":", ":", "dsub_7", "=", "=", "ARM", ":", ":", "dsub_0", "+", "<NUM_LIT>", "&", "&", "<STR_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "ARM", ":", ":", "dsub_0", "+", "N", "-", ">", "getZExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "DSubReg_i32_reg", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "assert", "(", "ARM", ":", ":", "dsub_7", "=", "=", "ARM", ":", ":", "dsub_0", "+", "<NUM_LIT>", "&", "&", "<STR_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "ARM", ":", ":", "dsub_0", "+", "N", "-", ">", "getZExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "DSubReg_f64_reg", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "assert", "(", "ARM", ":", ":", "dsub_7", "=", "=", "ARM", ":", ":", "dsub_0", "+", "<NUM_LIT>", "&", "&", "<STR_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "ARM", ":", ":", "dsub_0", "+", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "SSubReg_f32_reg", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "assert", "(", "ARM", ":", ":", "ssub_3", "=", "=", "ARM", ":", ":", "ssub_0", "+", "<NUM_LIT>", "&", "&", "<STR_LIT>", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "ARM", ":", ":", "ssub_0", "+", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "SubReg_i8_lane", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ ")", ";" ]

[ "Register", "TL45RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TL45Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "TL45Subtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(" ]

[ "}" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "ShiftedImmAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ",", "i32imm", ")", ";" ]

[ "_", "_", "m256i", "_", "_", "W", ")", "{" ]

[ "extern", "_", "_", "inline", "char", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_reduce_add_epi8", "(" ]

[ "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isNewValueJump", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", "||", "isEndLoopN", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\nCannot predicate:", "<STR_LIT>", ";", "MI", ".", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "<STR_LIT>", "Expected predicable instruction", "<STR_LIT>", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "<NUM_LIT>", ",", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "addOperand", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", ".", "getNumOperands", "(", ")", ")", "MI", ".", "RemoveOperand", "(", "n", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", ".", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "T", "->", "getIterator", "(", ")", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "I", "!=", "E", ";", "++", "I", ")", "{" ]

[ "assert", "(", "SU", "->", "getInstr", "(", ")", "&&", "<STR_LIT>", "Scheduled SUnit must have instr", "<STR_LIT>", ")", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";" ]

[ "}" ]

[ "vld1_lane_p8", "(", "const", "poly8_t", "*", "_", "_", "a", ",", "poly8x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "poly8x8_t", ")", "_", "_", "builtin_neon_vld1_lanev8qi", "(", "(", "const", "_", "_", "builtin_neon_qi", "*", ")", "_", "_", "a", ",", "(", "int8x8_t", ")", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "}" ]

[ "auto", "*", "TLIP", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "TLI", "=", "TLIP", "?", "&", "TLIP", "->", "getTLI", "(", "*", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", ")", ":", "nullptr", ";", "DL", "=", "&", "L", "->", "getHeader", "(", ")", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "this", "->", "L", "=", "L", ";", "ActiveLaneMask", "=", "nullptr", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", "||", "!", "ST", "->", "hasV8_1MMainlineOps", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: Not a v8.1m.main+mve target.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "BasicBlock", "*", "Preheader", "=", "L", "->", "getLoopPreheader", "(", ")", ";", "if", "(", "!", "Preheader", ")", "return", "false", ";", "auto", "FindLoopIterations", "=", "[", "]", "(", "BasicBlock", "*", "BB", ")", "->", "IntrinsicInst", "*", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "auto", "*", "Call", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "Intrinsic", "::", "ID", "ID", "=", "Call", "->", "getIntrinsicID", "(", ")", ";", "if", "(", "ID", "==", "Intrinsic", "::", "set_loop_iterations", "||", "ID", "==", "Intrinsic", "::", "test_set_loop_iterations", ")", "return", "cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "}", "return", "nullptr", ";", "}", ";", "IntrinsicInst", "*", "Setup", "=", "FindLoopIterations", "(", "Preheader", ")", ";", "if", "(", "!", "Setup", ")", "{", "if", "(", "!", "Preheader", "->", "getSinglePredecessor", "(", ")", ")", "return", "false", ";", "Setup", "=", "FindLoopIterations", "(", "Preheader", "->", "getSinglePredecessor", "(", ")", ")", ";", "if", "(", "!", "Setup", ")", "return", "false", ";", "}", "IntrinsicInst", "*", "Decrement", "=", "nullptr", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "IsDecrement", "(", "I", ")", ")", "{", "Decrement", "=", "cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "break", ";" ]

[ "<FIXS>", "if", "(", "ssevecmode", ">", "mode", "=", "=", "V4SFmode", ")", "emit_insn", "(", "gen_floatv4siv4sf2", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "elseemit_insn", "(", "gen_sse2_cvtdq2pd", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<FIXE>" ]

[ "emit_insn", "(", "gen_sse2_loadld", "(", "operands", "[", "<NUM_LIT>", "]", ",", "CONST0_RTX", "(", "V4SImode", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGS>", "emit_insn", "(", "gen_sse2_cvtdq2", "ssevecmodesuffix", ">", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGE>", "DONE", "}", ")" ]

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

[ "if", "(", "m", "==", "PSImode", "&&", "msp430x", ")", "return", "true", ";", "if", "(", "m", "==", "TImode" ]

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

[ "CPAddr", "=", "DAG", ".", "getTargetConstantPool", "(", "CPV", ",", "PtrVT", ",", "<NUM_LIT>", ")", ";", "CPAddr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "CPAddr", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CPAddr", ",", "MachinePointerInfo", "::", "getConstantPool", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "if", "(", "RelocM", "==", "Reloc", "::", "PIC_", ")", "{", "SDValue", "PICLabel", "=", "DAG", ".", "getConstant", "(", "ARMPCLabelIndex", ",", "MVT", "::", "i32", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "Result", ",", "PICLabel", ")", ";", "}", "return", "Result", ";", "}", "case", "Intrinsic", "::", "arm_neon_vmulls", ":", "case", "Intrinsic", "::", "arm_neon_vmullu", ":", "{", "unsigned", "NewOpc", "=", "(", "IntNo", "==", "Intrinsic", "::", "arm_neon_vmulls", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "let", "Pattern", "=", "[", "]", ";" ]

[ "Format", "F", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "Form", "=", "F", ".", "Value", ";" ]

[ "let", "isPredicatedNew", "=", "<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", "=", "BaseRegOffset", ";", "let", "accessSize", "=", "ByteAccess", ";" ]

[ ")" ]

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

[ "<FIXS>", "if", "(", "VGPR32", ".", "contains", "(", "Sub", ")", "&&", "(", "(", "Sub", "-", "AMDGPU", "::", "VGPR0", ")", "&", "<NUM_LIT>", ")", ")", "<FIXE>", "<FIXS>", "if", "(", "AGPR32", ".", "contains", "(", "Sub", ")", "&&", "(", "(", "Sub", "-", "AMDGPU", "::", "AGPR0", ")", "&", "<NUM_LIT>", ")", ")", "<FIXE>" ]

[ "if", "(", "!", "Sub", ")", "continue", ";", "<BUGS>", "if", "(", "VGRP32", ".", "contains", "(", "Sub", ")", "&&", "(", "(", "Sub", "-", "AMDGPU", "::", "VGPR0", ")", "&", "<NUM_LIT>", ")", ")", "<BUGE>", "return", "false", ";", "<BUGS>", "if", "(", "AGRP32", ".", "contains", "(", "Sub", ")", "&&", "(", "(", "Sub", "-", "AMDGPU", "::", "AGPR0", ")", "&", "<NUM_LIT>", ")", ")", "<BUGE>", "return", "false", ";", "}" ]

[ "<FIXS>", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", "&&", "!", "isSoftFP16", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSimpleValueType", "(", ")", ")", ")", "{", "<FIXE>" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Cmp", ",", "Op1", ",", "Op2", ")", ";", "}", "<BUGS>", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", ")", "{", "<BUGE>", "if", "(", "SDValue", "NewCond", "=", "LowerSETCC", "(", "Cond", ",", "DAG", ")", ")", "{", "Cond", "=", "NewCond", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "CC", "FLAGS_REG", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "MODEF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "absneg", ":", "MODEF", "(", "match_operand", ":", "MODEF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":" ]

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

[ "return", "(", "uint16x8_t", ")", "_", "_", "builtin_aarch64_ushll2_nv16qi", "(", "(", "int8x16_t", ")", "_", "_", "a", "," ]

[ "}" ]

[ "EVT", "MipsTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";" ]

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

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

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

[ "(", "define_mode_iterator", "REDUC_SSE_PLUS_MODE", "[", "(", "V2DF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")" ]

[ "let", "isMoveImm", "=", "<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>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

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

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

[ "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "<NUM_LIT>", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "Value", ")", "&&", "<STR_LIT>", "Value does not fit in the Fixup field", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ ")", "_", "<NUM_LIT>", ",", "(", "v4f64", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvfcmp_saf_d", "(", "(", "v4f64" ]

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

[ "dag", "ZELi8i64", "=", "(", "i64", "(", "zextloadi8", "xoaddr", ":", "$", "src", ")", ")", ";" ]

[ "dag", "Li8", "=", "(", "i32", "(", "extloadi8", "xoaddr", ":", "$", "src", ")", ")", ";", "dag", "ZELi8", "=", "(", "i32", "(", "zextloadi8", "xoaddr", ":", "$", "src", ")", ")", ";" ]

[ "}" ]

[ "intptr_t", "LazyPtr", "=", "getIndirectSymAddr", "(", "Fn", ")", ";", "if", "(", "!", "LazyPtr", ")", "{", "LazyPtr", "=", "(", "intptr_t", ")", "emitGlobalValueIndirectSym", "(", "(", "GlobalValue", "*", ")", "F", ",", "Fn", ",", "JCE", ")", ";", "if", "(", "F", ")", "DOUT", "<<", "<STR_LIT>", "JIT: Indirect symbol emitted at [", "<STR_LIT>", "<<", "LazyPtr", "<<", "<STR_LIT>", "] for GV '", "<STR_LIT>", "<<", "F", "->", "getName", "(", ")", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ";", "else", "DOUT", "<<", "<STR_LIT>", "JIT: Stub emitted at [", "<STR_LIT>", "<<", "LazyPtr", "<<", "<STR_LIT>", "] for external function at '", "<STR_LIT>", "<<", "Fn", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ";", "}", "JCE", ".", "startGVStub", "(", "F", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "intptr_t", "Addr", "=", "(", "intptr_t", ")", "JCE", ".", "getCurrentPCValue", "(", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "LazyPtr", "-", "(", "Addr", "+", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ")", ";", "sys", "::", "Memory", "::", "InvalidateInstructionCache", "(", "(", "void", "*", ")", "Addr", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "JCE", ".", "startGVStub", "(", "F", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "intptr_t", "Addr", "=", "(", "intptr_t", ")", "JCE", ".", "getCurrentPCValue", "(", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "(", "intptr_t", ")", "Fn", ")", ";", "sys", "::", "Memory", "::", "InvalidateInstructionCache", "(", "(", "void", "*", ")", "Addr", ",", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "JCE", ".", "startGVStub", "(", "F", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "intptr_t", "Addr", "=", "(", "intptr_t", ")", "JCE", ".", "getCurrentPCValue", "(", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordLE", "(", "(", "intptr_t", ")", "ARMCompilationCallback", ")", ";", "sys", "::", "Memory", "::", "InvalidateInstructionCache", "(", "(", "void", "*", ")", "Addr", ",", "<NUM_LIT>", ")", ";", "}", "return", "JCE", ".", "finishGVStub", "(", "F", ")", ";" ]