Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ")" ]

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

[ "emit_move_insn", "(", "reg", ",", "target", ")", ";" ]

[ "void", "s390_emit_tpf_eh_return", "(", "rtx", "target", ")", "{", "rtx", "insn", ",", "reg", ";", "if", "(", "!", "s390_tpf_eh_return_symbol", ")", "s390_tpf_eh_return_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__tpf_eh_return", "<STR_LIT>", ")", ";", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "if", "(", "tmp", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ENDLOOP", "||", "tmp", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ENDIF", "||", "tmp", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ELSE", ")", "{", "if", "(", "tmp", "==", "MBB", "->", "begin", "(", ")", ")", "{", "return", "tmp", ";", "}", "else", "{", "continue", ";" ]

[ ",", "(", "VLDRH", "addrmode5fp16", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "FPRegs16Pat", "<", "(", "f16", "(", "alignedload16", "addrmode5fp16", ":", "$", "addr", ")", ")" ]

[ "}" ]

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

[ "<STR_LIT>" ]

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

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

[ "def", "F2_dfcmpuo", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeALU64", ">", ",", "Enc_fcf7a7", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "mips_got_load", "(", "NULL", ",", "operands", "[" ]

[ "CoordTy", "GPR32", ":", "$", "coordDepth", ")", ",", "(", "CoordTy", "GPR32", ":", "$", "src9", ")", ")", "]", ">", ";" ]

[ "class", "StImage3d", "<", "Intrinsic", "intr", ",", "string", "asm", ",", "ValueType", "ValTy", ",", "ValueType", "CoordTy", ">", ":", "HSAILInst", "<", "(", "outs", ")", ",", "(", "ins", "GPR32", ":", "$", "srcR", ",", "GPR32", ":", "$", "srcG", ",", "GPR32", ":", "$", "srcB", ",", "GPR32", ":", "$", "srcA", ",", "GPR64", ":", "$", "image", ",", "GPR32", ":", "$", "coordWidth", ",", "GPR32", ":", "$", "coordHeight", ",", "GPR32", ":", "$", "coordDepth", ",", "GPR32", ":", "$", "src9", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", "<STR_LIT>", ")", ",", "[", "(", "intr", "(", "ValTy", "GPR32", ":", "$", "srcR", ")", ",", "(", "ValTy", "GPR32", ":", "$", "srcG", ")", ",", "(", "ValTy", "GPR32", ":", "$", "srcB", ")", ",", "(", "ValTy", "GPR32", ":", "$", "srcA", ")", ",", "(", "i64", "GPR64", ":", "$", "image", ")", ",", "(", "CoordTy", "GPR32", ":", "$", "coordWidth", ")", ",", "(", "CoordTy", "GPR32", ":", "$", "coordHeight", ")", ",", "(" ]

[ "if", "(", "isXReg", ")", "{" ]

[ "Error", "(", "S", ",", "<STR_LIT>", "expected register", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "int", "FirstReg", "=", "tryParseRegister", "(", ")", ";", "if", "(", "FirstReg", "==", "-", "<NUM_LIT>", ")", "{", "return", "MatchOperand_ParseFail", ";", "}", "const", "MCRegisterClass", "&", "WRegClass", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ";", "const", "MCRegisterClass", "&", "XRegClass", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ";", "bool", "isXReg", "=", "XRegClass", ".", "contains", "(", "FirstReg", ")", ",", "isWReg", "=", "WRegClass", ".", "contains", "(", "FirstReg", ")", ";", "if", "(", "!", "isXReg", "&&", "!", "isWReg", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "expected first even register of a ", "<STR_LIT>", "<STR_LIT>", "consecutive same-size even/odd register pair", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "const", "MCRegisterInfo", "*", "RI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FirstEncoding", "=", "RI", "->", "getEncodingValue", "(", "FirstReg", ")", ";", "if", "(", "FirstEncoding", "&", "<NUM_LIT>", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "expected first even register of a ", "<STR_LIT>", "<STR_LIT>", "consecutive same-size even/odd register pair", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "SMLoc", "M", "=", "getLoc", "(", ")", ";", "if", "(", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Error", "(", "M", ",", "<STR_LIT>", "expected comma", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "SMLoc", "E", "=", "getLoc", "(", ")", ";", "int", "SecondReg", "=", "tryParseRegister", "(", ")", ";", "if", "(", "SecondReg", "==", "-", "<NUM_LIT>", ")", "{", "return", "MatchOperand_ParseFail", ";", "}", "if", "(", "RI", "->", "getEncodingValue", "(", "SecondReg", ")", "!=", "FirstEncoding", "+", "<NUM_LIT>", "||", "(", "isXReg", "&&", "!", "XRegClass", ".", "contains", "(", "SecondReg", ")", ")", "||", "(", "isWReg", "&&", "!", "WRegClass", ".", "contains", "(", "SecondReg", ")", ")", ")", "{", "Error", "(", "E", ",", "<STR_LIT>", "expected second odd register of a ", "<STR_LIT>", "<STR_LIT>", "consecutive same-size even/odd register pair", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "unsigned", "Pair", "=", "<NUM_LIT>", ";" ]

[ ")" ]

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

[ "return", "LDepth", "<", "RDepth", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";" ]

[ "static", "int", "BUCompareLatency", "(", "const", "SUnit", "*", "left", ",", "const", "SUnit", "*", "right", ")", "{", "int", "LHeight", "=", "(", "int", ")", "left", "->", "getHeight", "(", ")", ";", "int", "RHeight", "=", "(", "int", ")", "right", "->", "getHeight", "(", ")", ";", "if", "(", "LHeight", "!=", "RHeight", ")", "return", "LHeight", ">", "RHeight", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";", "int", "LDepth", "=", "left", "->", "getDepth", "(", ")", ";", "int", "RDepth", "=", "right", "->", "getDepth", "(", ")", ";", "if", "(", "LDepth", "!=", "RDepth", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Comparing latency of SU (", "<STR_LIT>", "<<", "left", "->", "NodeNum", "<<", "<STR_LIT>", ") depth ", "<STR_LIT>", "<<", "LDepth", "<<", "<STR_LIT>", " vs SU (", "<STR_LIT>", "<<", "right", "->", "NodeNum", "<<", "<STR_LIT>", ") depth ", "<STR_LIT>", "<<", "RDepth", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";", "}", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "SKLWriteResGroup10", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "rtx", "function_expander", "::", "use_vcond_mask_insn", "(", "insn_code", "icode", ",", "unsigned", "int", "merge_argno", ")", "{", "machine_mode", "mode", "=", "vector_mode", "(", "<NUM_LIT>", ")", ";", "unsigned", "int", "opno", "=", "<NUM_LIT>", ";", "rtx", "false_arg", "=", "get_fallback_value", "(", "mode", ",", "<NUM_LIT>", ",", "merge_argno", ",", "opno", ")", ";", "rtx", "pred_arg", "=", "args", "[", "opno", "++", "]", ";", "rtx", "true_arg", "=", "args", "[", "opno", "++", "]", ";", "add_output_operand", "(", "icode", ")", ";", "add_input_operand", "(", "icode", ",", "true_arg", ")", ";", "add_input_operand", "(", "icode", ",", "false_arg", ")", ";", "add_input_operand", "(", "icode", ",", "pred_arg", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "which", "is", "a", "select-like", "operation", "with", "the", "following", "operands", ":", "0", ":", "output", "1", ":", "true", "value", "2", ":", "false", "value", "3", ":", "predicate", "MERGE_ARGNO", "is", "the", "argument", "that", "provides", "the", "``", "false", "''", "value", "for", "_m", "functions", ",", "or", "DEFAULT_MERGE_ARGNO", "if", "we", "should", "apply", "the", "usual", "rules", "." ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "Switches", "=", "<NUM_LIT>", ";", "let", "Dest", "=", "dst", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "OperandType", "=", "OpType", ".", "INT64", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

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

[ "amdgcn_image_sample_c_b_cl_o", ":" ]

[ "case", "Intrinsic", "::", "amdgcn_tbuffer_load", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTList", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "Chain", "=", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "return", "adjustLoadValueType", "(", "Res", ",", "LoadVT", ",", "DL", ",", "DAG", ",", "Unpacked", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_buffer_load_format", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTList", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "Chain", "=", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "return", "adjustLoadValueType", "(", "Res", ",", "LoadVT", ",", "DL", ",", "DAG", ",", "Unpacked", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_image_load", ":", "case", "Intrinsic", "::", "amdgcn_image_load_mip", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "unsigned", "Opc", "=", "getImageOpcode", "(", "IID", ")", ";", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "VTList", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "Chain", "=", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "return", "adjustLoadValueType", "(", "Res", ",", "LoadVT", ",", "DL", ",", "DAG", ",", "Unpacked", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_image_sample", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_d", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_d_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_l", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_b", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_b_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_lz", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cd", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cd_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_d", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_d_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_l", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_b", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_b_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_lz", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_cd", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_cd_cl", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_d_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_d_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_l_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_b_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_b_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_lz_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cd_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_cd_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_d_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_d_cl_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_l_o", ":", "case", "Intrinsic", "::", "amdgcn_image_sample_c_b_o", ":", "case", "Intrinsic", "::" ]

[ "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "float64x1_t", ")", "{", "_", "_", "builtin_aarch64_get_dregxidf", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", "}", ";" ]

[ "_", "_", "o", "=", "_", "_", "builtin_aarch64_ld4rdf", "(", "(", "const", "_", "_", "builtin_aarch64_simd_df", "*", ")", "_", "_", "a", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "float64x1_t", ")", "{", "_", "_", "builtin_aarch64_get_dregxidf", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", "}", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "float64x1_t", ")", "{", "_", "_", "builtin_aarch64_get_dregxidf", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", "}", ";" ]

[ "}", "else", "if", "(", "CPUString", "==", "<STR_LIT>", "hexagonv5", "<STR_LIT>", ")", "{" ]

[ "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "<STR_LIT>", "hexagonv4", "<STR_LIT>", ";", "if", "(", "CPUString", "==", "<STR_LIT>", "hexagonv4", "<STR_LIT>", ")", "{", "HexagonArchVersion", "=", "V4", ";" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "QISI", "[", "QI", "HI", "PSI", "SI", "]", ")", "(", "define_mode_iterator", "QIDI", "[", "QI", "HI", "PSI", "SI", "DI" ]

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

[ "auto", "IsHFPR", "=", "[", "&", "]", "(", "const", "MachineOperand", "&", "Op", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "false", ";", "auto", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ".", "isPhysical", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains" ]

[ "if", "(", "uint64_t", "CalleeAmt", "=", "TII", ".", "getFramePoppedByCallee", "(", "*", "I", ")", ")", "{" ]

[ "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "TII", ".", "getFramePoppedByCallee", "(", "Old", ")", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{" ]

[ "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "(", "MIa", ".", "mayLoad", "(", ")", "||", "MIa", ".", "mayStore", "(", ")", ")", "&&", "<STR_LIT>", "MIa must load from or modify a memory location", "<STR_LIT>", ")", ";", "assert", "(", "(", "MIb", ".", "mayLoad", "(", ")", "||", "MIb", ".", "mayStore", "(", ")", ")", "&&", "<STR_LIT>", "MIb must load from or modify a memory location", "<STR_LIT>", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "isDS", "(", "MIa", ")", ")", "{", "if", "(", "isDS", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "||", "isSegmentSpecificFLAT", "(", "MIb", ")", ";", "}", "if", "(", "isMUBUF", "(", "MIa", ")", "||", "isMTBUF", "(", "MIa", ")", ")", "{", "if", "(", "isMUBUF", "(", "MIb", ")", "||", "isMTBUF", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isSMRD", "(", "MIb", ")", ";", "}", "if", "(", "isSMRD", "(", "MIa", ")", ")", "{", "if", "(", "isSMRD", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isMUBUF", "(", "MIa", ")", "&&", "!", "isMTBUF", "(", "MIa", ")", ";", "}", "if", "(", "isFLAT", "(", "MIa", ")", ")", "{", "if", "(", "isFLAT", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ ";" ]

[ "def", "MADDV_H", ":", "MADDV_H_ENC", ",", "MADDV_H_DESC" ]

[ "LIS", "->", "removeInterval", "(", "SaveExecReg", ")", ";" ]

[ "MachineInstr", "*", "Xor", "=", "nullptr", ";", "if", "(", "!", "SimpleIf", ")", "{", "Xor", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "XorOpc", ")", ",", "SaveExecReg", ")", ".", "addReg", "(", "Tmp", ")", ".", "addReg", "(", "CopyReg", ")", ";", "setImpSCCDefDead", "(", "*", "Xor", ",", "ImpDefSCC", ".", "isDead", "(", ")", ")", ";", "}", "MachineInstr", "*", "SetExec", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "MovTermOpc", ")", ",", "Exec", ")", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "LV", ")", "LV", "->", "getVarInfo", "(", "Tmp", ")", ".", "Kills", ".", "push_back", "(", "SetExec", ")", ";", "I", "=", "skipToUncondBrOrEnd", "(", "MBB", ",", "I", ")", ";", "MachineInstr", "*", "NewBr", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_CBRANCH_EXECZ", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "LIS", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "return", ";", "}", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "CopyExec", ")", ";", "LIS", "->", "ReplaceMachineInstrInMaps", "(", "MI", ",", "*", "And", ")", ";", "if", "(", "!", "SimpleIf", ")", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "Xor", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "SetExec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "NewBr", ")", ";", "LIS", "->", "removeAllRegUnitsForPhysReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";" ]

[ "void", "pru_register_abicheck_pass", "(", "void", ")", "{", "opt_pass", "*", "tiabi_check", "=", "make_pass_tiabi_check", "(", "g", ")", ";", "struct", "register_pass_info", "tiabi_check_info", "=", "{", "tiabi_check", ",", "<STR_LIT>", "*warn_unused_result", "<STR_LIT>", ",", "<NUM_LIT>", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "tiabi_check_info", ")", ";", "}" ]

[ "Register", "as", "early", "as", "possible", "." ]

[ "BuildMI", "(", "LoopMBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "AddrReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "BuildMI", "(", "LoopMBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addReg", "(", "IncrReg", ")", ";", "break", ";", "case", "AtomicRMWInst", "::", "Nand", ":", "BuildMI", "(", "LoopMBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addReg", "(", "IncrReg", ")", ";", "BuildMI", "(", "LoopMBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "insertMaskedMerge", "(", "TII", ",", "DL", ",", "LoopMBB", ",", "ScratchReg", ",", "DestReg", ",", "ScratchReg", ",", "MaskReg", ",", "ScratchReg", ")", ";" ]

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

[ "class", "MVE_bit_cmode", "<", "string", "iname", ",", "string", "suffix", ",", "bit", "halfword", ",", "dag", "inOps", ">", ":", "MVE_p", "<", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "inOps", ",", "NoItinerary", ",", "iname", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_n", ",", "<STR_LIT>", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "bits", "<", "<NUM_LIT>", ">", "Qd", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "}", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "FP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "FP", "(", "float", ":", "FP", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "FP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "return", "TARGET_68040", "?", "<STR_LIT>", ":", "<STR_LIT>", "}" ]

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

[ "def", "J4_cmpgtui_t_jumpnv_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_eafd18", ",", "PredRel", "{", "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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "vreinterpret_s64_p8", "(", "poly8x8_t", "_", "_", "a", ")", "{", "return", "(", "int64x1_t", ")", "_", "_", "a", ";" ]

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

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_pcmpeqq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")", "_", "_", "B", "," ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<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>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Unpredictable", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<NUM_LIT>", ";" ]

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

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

[ "def", "v8i16", ":", "BaseSIMDModifiedImmVectorShiftHalf", "<", "<NUM_LIT>", ",", "op", ",", "hw_cmode", ",", "V128", ",", "asm", ",", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<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>", ";" ]

[ "<FIXS>", "*", "cost", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed_p", ")", ";", "<FIXE>" ]

[ "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "{", "<BUGS>", "*", "cost", "+=", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "code", ",", "<NUM_LIT>", ",", "speed_p", ")", ";", "<BUGE>", "return", "true", ";", "}" ]

[ "case", "CEK_TP_HI", ":" ]

[ "break", ";", "case", "CEK_CALL_HI16", ":", "OS", "<<", "<STR_LIT>", "%call_hi", "<STR_LIT>", ";", "break", ";", "case", "CEK_CALL_LO16", ":", "OS", "<<", "<STR_LIT>", "%call_lo", "<STR_LIT>", ";", "break", ";", "case", "CEK_DTP_HI", ":", "OS", "<<", "<STR_LIT>", "%dtp_hi", "<STR_LIT>", ";", "break", ";", "case", "CEK_DTP_LO", ":", "OS", "<<", "<STR_LIT>", "%dtp_lo", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOT", ":", "OS", "<<", "<STR_LIT>", "%got", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOTTPREL", ":", "OS", "<<", "<STR_LIT>", "%gottprel", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOT_CALL", ":", "OS", "<<", "<STR_LIT>", "%call16", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOT_DISP", ":", "OS", "<<", "<STR_LIT>", "%got_disp", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOT_HI16", ":", "OS", "<<", "<STR_LIT>", "%got_hi", "<STR_LIT>", ";", "break", ";", "case", "CEK_GOT_LO16", ":", "OS", "<<", "<STR_LIT>", "%got_lo", "<STR_LIT>", ";", "break", ";", "case", "CEK_GPREL", ":", "OS", "<<", "<STR_LIT>", "%gp_rel", "<STR_LIT>", ";", "break", ";", "case", "CEK_ABS_HI", ":", "OS", "<<", "<STR_LIT>", "%hi", "<STR_LIT>", ";", "break", ";", "case", "CEK_ABS_LO", ":", "OS", "<<", "<STR_LIT>", "%lo", "<STR_LIT>", ";", "break", ";", "case", "CEK_TLSGD", ":", "OS", "<<", "<STR_LIT>", "%tlsgd", "<STR_LIT>", ";", "break", ";", "case", "CEK_TLSLDM", ":", "OS", "<<", "<STR_LIT>", "%tlsldm", "<STR_LIT>", ";", "break", ";" ]

[ "<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>", ")", "(", "and", "(", "eq_attr" ]

[ "}" ]

[ "vbfdot_lane_f32", "(", "float32x2_t", "_", "_", "r", ",", "bfloat16x4_t", "_", "_", "a", ",", "bfloat16x4_t", "_", "_", "b", ",", "const", "int", "_", "_", "index", ")", "{", "return", "_", "_", "builtin_neon_vbfdot_lanev4bfv2sf", "(", "_", "_", "r", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "index", ")", ";" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Can only put epilog before 'retl' instruction!", "<STR_LIT>", ")", ";" ]

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

[ "let", "isPredicated", "=", "<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", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign" ]

[ "DL", ",", "SrcVT", ",", "Mask", ",", "MinPos", ")", ";" ]

[ "if", "(", "ExtractVT", "!=", "MVT", "::", "i16", ")", "return", "SDValue", "(", ")", ";", "unsigned", "BinOp", ";", "SDValue", "Src", "=", "matchBinOpReduction", "(", "Extract", ",", "BinOp", ",", "{", "ISD", "::", "SMAX", ",", "ISD", "::", "SMIN", ",", "ISD", "::", "UMAX", ",", "ISD", "::", "UMIN", "}", ")", ";", "if", "(", "!", "Src", ")", "return", "SDValue", "(", ")", ";", "EVT", "SrcVT", "=", "Src", ".", "getValueType", "(", ")", ";", "EVT", "SrcSVT", "=", "SrcVT", ".", "getScalarType", "(", ")", ";", "if", "(", "SrcSVT", "!=", "MVT", "::", "i16", "||", "(", "SrcVT", ".", "getSizeInBits", "(", ")", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "Extract", ")", ";", "SDValue", "MinPos", "=", "Src", ";", "while", "(", "SrcVT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", "{", "unsigned", "NumElts", "=", "SrcVT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "NumSubElts", "=", "NumElts", "/", "<NUM_LIT>", ";", "SrcVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "SrcSVT", ",", "NumSubElts", ")", ";", "unsigned", "SubSizeInBits", "=", "SrcVT", ".", "getSizeInBits", "(", ")", ";", "SDValue", "Lo", "=", "extractSubVector", "(", "MinPos", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ",", "SubSizeInBits", ")", ";", "SDValue", "Hi", "=", "extractSubVector", "(", "MinPos", ",", "NumSubElts", ",", "DAG", ",", "DL", ",", "SubSizeInBits", ")", ";", "MinPos", "=", "DAG", ".", "getNode", "(", "BinOp", ",", "DL", ",", "SrcVT", ",", "Lo", ",", "Hi", ")", ";", "}", "assert", "(", "SrcVT", "==", "MVT", "::", "v8i16", "&&", "<STR_LIT>", "Unexpected value type", "<STR_LIT>", ")", ";", "SDValue", "Mask", ";", "if", "(", "BinOp", "==", "ISD", "::", "SMAX", ")", "Mask", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignedMaxValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "SrcVT", ")", ";", "else", "if", "(", "BinOp", "==", "ISD", "::", "SMIN", ")", "Mask", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignedMinValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "SrcVT", ")", ";", "else", "if", "(", "BinOp", "==", "ISD", "::", "UMAX", ")", "Mask", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getAllOnesValue", "(", "<NUM_LIT>", ")", ",", "DL", ",", "SrcVT", ")", ";", "if", "(", "Mask", ")", "MinPos", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", "," ]

[ "let", "isExtendable", "=", "<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", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";" ]

[ "<FIXS>", "Register", "AmountReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "WIN_ALLOCA_64", ")", ";", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", ";", "<BUGS>", "unsigned", "AmountReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "MachineInstr", "*", "Def", "=", "MRI", "->", "getUniqueVRegDef", "(", "AmountReg", ")", ";", "if", "(", "!", "Def", "||" ]

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

[ "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_extr_r_w", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_extr_rs_w", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_extr_s_h", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_mthlip", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_mulsaq_s_w_ph", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_maq_s_w_phl", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "mips_maq_s_w_phr", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::" ]

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

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "STRWui", "(", "EXTRACT_SUBREG", "GPR64", ":", "$", "Rt", ",", "sub_32", ")", ",", "GPR64sp", ":", "$", "Rn", ",", "uimm12s4", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "truncstorei32", "GPR64", ":", "$", "Rt", ",", "(", "am_indexed32", "GPR64sp", ":", "$", "Rn", ",", "uimm12s4", ":", "$", "offset", ")", ")", ",", "(" ]

[ ")", ";" ]

[ "if", "(", "Value", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "Value", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ConstantFP", ")", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "(", "VT", ".", "getVectorNumElements", "(", ")", ",", "Value", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "VT", ",", "Ops", ")", ";", "}", "if", "(", "Value", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VT", ",", "Value" ]

[ "}" ]

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

[ "return", ";" ]

[ "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "BUFFER_STORE_DWORD_OFFSET", ")", ")", ".", "addReg", "(", "SpillReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "ScratchRsrcReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Offset", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "gen_reg_rtx", "(", "<", "MODE", ">", "mode", ")", "," ]

[ "(", "clobber", "(", "reg", ":", "SI", "R0_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R1_REG", ")", ")", "]", "<STR_LIT>", "{", "return", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "}", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "emit_insn", "(", "gen_atomic_not_fetch", "<", "mode", ">", "_soft_gusa", "(" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "ComparisonAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "i8imm", ":", "$", "cmp", ")", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "Register", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "<FIXE>", "<FIXS>", "Register", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "<FIXE>", "<FIXS>", "Register", "FullDestReg", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestRC", ")", ";", "<FIXE>" ]

[ "const", "TargetRegisterClass", "*", "NewDestRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "DestRC", ")", ";", "const", "TargetRegisterClass", "*", "NewDestSubRC", "=", "RI", ".", "getSubRegClass", "(", "NewDestRC", ",", "AMDGPU", "::", "sub0", ")", ";", "<BUGS>", "unsigned", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "<BUGE>", "MachineInstr", "&", "LoHalf", "=", "*", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub0", ")", ".", "add", "(", "SrcReg0Sub0", ")", ";", "MachineOperand", "SrcReg0Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub1", ",", "Src0SubRC", ")", ";", "<BUGS>", "unsigned", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "<BUGE>", "MachineInstr", "&", "HiHalf", "=", "*", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub1", ")", ".", "add", "(", "SrcReg0Sub1", ")", ";", "<BUGS>", "unsigned", "FullDestReg", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestRC", ")", ";", "<BUGE>", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "FullDestReg", ")", ".", "addReg", "(", "DestSub0", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0", ")" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "def", "STRICT_WWM", ":", "PseudoInstSI", "(", "outs", "unknown", ":", "$", "vdst", ")", ",", "(", "ins", "unknown", ":", "$", "src0", ")", ">", ";", "<FIXE>", "<FIXS>", "def", "ENTER_STRICT_WWM", ":", "SPseudoInstSI", "(", "outs", "SReg_1", ":", "$", "sdst", ")", ",", "(", "ins", "i64imm", ":", "$", "src0", ")", ">", "{", "<FIXE>" ]

[ "def", "SOFT_WQM", ":", "PseudoInstSI", "(", "outs", "unknown", ":", "$", "vdst", ")", ",", "(", "ins", "unknown", ":", "$", "src0", ")", ">", ";", "<BUGS>", "<BUGE>", "<BUGS>", "<BUGE>", "let", "Constraints", "=", "<STR_LIT>", "in", "{", "<BUGS>", "def", "WWM", ":", "PseudoInstSI", "(", "outs", "unknown", ":", "$", "vdst", ")", ",", "(", "ins", "unknown", ":", "$", "src0", ")", ">", ";", "<BUGE>", "}", "}", "<BUGS>", "def", "ENTER_WWM", ":", "SPseudoInstSI", "(", "outs", "SReg_1", ":", "$", "sdst", ")", ",", "(", "ins", "i64imm", ":", "$", "src0", ")", ">", "{", "<BUGE>", "let", "Uses", "=", "[", "EXEC", "]", ";", "let", "Defs", "=", "[", "EXEC", ",", "SCC", "]", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";" ]

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

[ "_", "_", "arm_vcreateq_u32", "(", "uint64_t", "_", "_", "a" ]

[ "i", ",", "SPOffset", "-", "StackSize", "+", "PrevStackSize", ")", ";" ]

[ "IsStoreInst", "=", "(", "Info", ".", "getDstReg", "(", ")", "==", "DstReg", ")", "&&", "(", "Info", ".", "getReg", "(", ")", "==", "Reg", ")", ";", "}", "else", "{", "Register", "Reg", "=", "TII", ".", "isStoreToStackSlot", "(", "*", "MBBI", ",", "StoreFI", ")", ";", "IsStoreInst", "=", "(", "Reg", "==", "Info", ".", "getReg", "(", ")", ")", "&&", "(", "StoreFI", "==", "FI", ")", ";", "}", "assert", "(", "IsStoreInst", "&&", "<STR_LIT>", "Unexpected callee-saved register store instruction", "<STR_LIT>", ")", ";", "++", "MBBI", ";", "}", "for", "(", "const", "auto", "&", "I", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "<NUM_LIT>", ")", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "FP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FP", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "if", "(", "StackSize", "!=", "PrevStackSize", ")", "{", "MFI", ".", "setStackSize", "(", "StackSize", ")", ";", "for", "(", "int", "i", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "i", "<", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "++", ")", "{", "if", "(", "!", "MFI", ".", "isDeadObjectIndex", "(", "i", ")", ")", "{", "int64_t", "SPOffset", "=", "MFI", ".", "getObjectOffset", "(", "i", ")", ";", "if", "(", "SPOffset", "<", "<NUM_LIT>", ")", "MFI", ".", "setObjectOffset", "(" ]

[ "}" ]

[ "int64_t", "Value", "=", "CE", "->", "getValue", "(", ")", ";", "return", "Value", ">=", "<NUM_LIT>", "&&", "Value", "<", "<NUM_LIT>", ";" ]

[ "<FIXS>", "Result", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "DAG", ".", "getVTList", "(", "VecT", ")", ",", "{", "SplattedLoad", "->", "getChain", "(", ")", ",", "SplattedLoad", "->", "getBasePtr", "(", ")", ",", "SplattedLoad", "->", "getOffset", "(", ")", "}", ",", "SplattedLoad", "->", "getMemoryVT", "(", ")", ",", "SplattedLoad", "->", "getMemOperand", "(", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "Subtarget", "->", "hasUnimplementedSIMD128", "(", ")", "&&", "(", "SplattedLoad", "=", "dyn_cast", "LoadSDNode", ">", "(", "SplatValue", ")", ")", "&&", "SplattedLoad", "->", "getMemoryVT", "(", ")", "==", "VecT", ".", "getVectorElementType", "(", ")", ")", "{", "<BUGS>", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VecT", ",", "SplatValue", ")", ";", "<BUGE>", "}", "else", "{", "Result", "=", "DAG", ".", "getSplatBuildVector", "(", "VecT", ",", "DL", ",", "SplatValue", ")", ";", "}" ]

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

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

[ "}" ]

[ "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "<NUM_LIT>", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "<NUM_LIT>", ")", "break", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "if", "(", "KnownZero", "==", "<NUM_LIT>", "&&", "KnownOne", "==", "<NUM_LIT>", ")", "return", ";", "APInt", "KnownZeroRHS", ",", "KnownOneRHS", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "KnownZeroRHS", ",", "KnownOneRHS", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "KnownZero", "&=", "KnownZeroRHS", ";", "KnownOne", "&=", "KnownOneRHS", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "KnownZero", "&=", "Mask", ";", "KnownOne", "&=", "Mask", ";", "return", ";", "}" ]

[ "-", "<NUM_LIT>", ",", "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvtt_roundph_epu64", "(", "_", "_", "m128h", "_", "_", "A", ",", "int", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_ia32_vcvttph2uqq512_mask_round", "(", "_", "_", "A", ",", "_", "mm512_setzero_si512", "(", ")", ",", "(", "_", "_", "mmask8", ")" ]

[ "}" ]

[ "State", ".", "addLoc", "(", "CCValAssign", "::", "getCustomMem", "(", "ValNo", ",", "ValVT", ",", "State", ".", "AllocateStack", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "return", "true", ";", "}", "if", "(", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ",", "<NUM_LIT>", ")", ")", "State", ".", "addLoc", "(", "CCValAssign", "::", "getCustomReg", "(", "ValNo", ",", "ValVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "else", "State", ".", "addLoc", "(", "CCValAssign", "::", "getCustomMem", "(", "ValNo", ",", "ValVT", ",", "State", ".", "AllocateStack", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "return", "true", ";" ]

[ "always_inline__", ")", ")", "_", "mm_castps_pd", "(", "_", "_", "m128", "_", "_", "A", ")", "{" ]

[ "static", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_" ]

[ "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "DIR_440", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "TII", "&&", "<STR_LIT>", "No InstrInfo?", "<STR_LIT>", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "TII", ")", ";", "}", "return", "TargetInstrInfoImpl", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ ";" ]

[ "if", "(", "ch", "==", "'", "q", "'", ")", "{", "type_suffix_index", "suffix", "=", "parse_element_type", "(", "instance", ",", "format", ")", ";", "return", "find_type_suffix", "(", "type_suffixes", "[", "suffix", "]", ".", "tclass", ",", "type_suffixes", "[", "suffix", "]", ".", "element_bits", "/", "<NUM_LIT>", ")", ";", "}", "if", "(", "ch", "==", "'", "h", "'", ")", "{", "type_suffix_index", "suffix", "=", "parse_element_type", "(", "instance", ",", "format", ")", ";", "if", "(", "suffix", "==", "TYPE_SUFFIX_b", ")", "return", "suffix", ";", "return", "find_type_suffix", "(", "type_suffixes", "[", "suffix", "]", ".", "tclass", ",", "type_suffixes", "[", "suffix", "]", ".", "element_bits", "/", "<NUM_LIT>", ")", ";", "}", "if", "(", "ch", "==", "'", "<NUM_LIT>", "'", "||", "ch", "==", "'", "<NUM_LIT>", "'", ")", "return", "instance", ".", "type_suffix_ids", "[", "ch", "-", "'", "<NUM_LIT>", "'", "]", ";", "gcc_unreachable", "(", ")" ]

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

[ "return", "_", "_", "builtin_ia32_reduceph128_mask", "(", "_", "_", "B", ",", "_", "_", "C", ",", "_", "mm_setzero_ph", "(", ")", "," ]

[ "}", "]", ">", ";" ]

[ "}", "]", ">", ";", "def", "NEONimmAllOnesV", ":", "PatLeaf", "<", "(", "NEONvmovImm", "(", "i32", "timm", ")", ")", ",", "[", "{", "ConstantSDNode", "*", "ConstVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "-", ">", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "EltBits", "=", "<NUM_LIT>", ";", "uint64_t", "EltVal", "=", "ARM_AM", ":", ":", "decodeNEONModImm", "(", "ConstVal", "-", ">", "getZExtValue", "(", ")", ",", "EltBits", ")", ";", "return", "(", "EltBits", "=", "=", "<NUM_LIT>", "&", "&", "EltVal", "=", "=", "<NUM_LIT>", ")", ";" ]

[ "return", "alignment", ";" ]

[ "unsigned", "int", "alignment", ";", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";" ]

[ "extloadi8", ">", ";" ]

[ "def", "VLD1LNq8Pseudo", ":", "VLD1QLNPseudo", "<", "v16i8", "," ]

[ "<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>", ";", "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>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

[ "<FIXS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR", ":", "$", "dst", ",", "so_imm", ":", "$", "src", ")", "]", ">", ",", "UnaryDP", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "}", "<FIXE>" ]

[ "let", "isReMaterializable", "=", "<NUM_LIT>", ",", "isAsCheapAsAMove", "=", "<NUM_LIT>", "indef", "MOVi", ":", "AsI1", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "dst", ")", ",", "(", "ins", "so_imm", ":", "$", "src", ")", ",", "DPFrm", ",", "IIC_iMOVi", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR", ":", "$", "dst", ",", "so_imm", ":", "$", "src", ")", "]", ">", ",", "UnaryDP", ";", "<BUGE>", "let", "Uses", "=", "[", "CPSR", "]", "indef", "MOVrx", ":", "AsI1", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "dst", ")", ",", "(", "ins", "GPR", ":", "$", "src", ")", ",", "Pseudo", ",", "IIC_iMOVsi", "," ]

[ ")", ")" ]

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

[ "<FIXS>", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "<FIXE>" ]

[ "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "<BUGS>", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "<BUGE>", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "uint64_t", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";" ]

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

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

[ "}" ]

[ "static", "bool", "mmix_rtx_costs", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m256i", "_", "_", "lasx_xvbitrev_d", "(", "_", "_", "m256i", "_", "<NUM_LIT>", ",", "_", "_", "m256i", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvbitrev_d", "(", "(", "v4u64", ")" ]

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

[ "bool", "isUnitBusy", "(", "unsigned", "unit", ")", "{", "assert", "(", "unit", "<", "UNITS", "*", "SIDES", ")", ";", "unsigned", "side", "=", "unit", "&", "<NUM_LIT>", ";", "if", "(", "Active", "[", "side", "]", ".", "count", "(", "unit", ")", ")", "return", "true", ";", "if", "(", "isLSD", "(", "unit", ">>", "<NUM_LIT>", ")", "&&", "moveUnitsAvailable", "(", "side", ")" ]

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

[ "class", "BaseSIMDModifiedImm", "<", "bit", "Q", ",", "bit", "op", ",", "bit", "op2", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ",", "string", "op_string", ",", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "oops", ",", "iops", ",", "asm", ",", "op_string", ",", "cstr", ",", "pattern", ">", ",", "Sched", "<", "[", "!", "if", "(", "Q", ",", "WriteVq", ",", "WriteVd", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "imm8", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "VCVTTQ_F16_F32", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "return", "NumBytes", ";" ]

[ "unsigned", "AlignMask", "=", "TargetAlign", "-", "<NUM_LIT>", ";", "NumBytes", "=", "(", "NumBytes", "+", "AlignMask", ")", "&", "~", "AlignMask", ";" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

[ "<FIXS>", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v16i8", ",", "Promote", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v16i16", ",", "Promote", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "MVT", "::", "v16i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v16i32", ",", "Legal", ")", ";", "<BUGS>", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v16i8", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v16i16", ",", "Legal", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v8i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v4i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "v2i32", ",", "Custom", ")", ";" ]

[ "<FIXS>", "unsigned", "Idx", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "return", "AMDGPU", "::", "SGPR91", ";", "<FIXE>" ]

[ "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasSGPRInitBug", "(", ")", ")", "{", "<BUGS>", "unsigned", "Idx", ";", "if", "(", "!", "ST", ".", "isXNACKEnabled", "(", ")", ")", "Idx", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "elseIdx", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "<BUGE>", "return", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "Idx", ")", ";", "}", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "<BUGS>", "if", "(", "!", "ST", ".", "isXNACKEnabled", "(", ")", ")", "{", "return", "AMDGPU", "::", "SGPR97", ";", "}", "else", "{", "return", "AMDGPU", "::", "SGPR91", ";", "}", "<BUGE>", "}", "return", "AMDGPU", "::", "SGPR95", ";" ]

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

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

[ "}" ]

[ "break", ";", "case", "Token", ":", "OS", "<<", "<STR_LIT>", "'", "<STR_LIT>", "<<", "getToken", "(", ")", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "break", ";", "}" ]

[ "}" ]

[ "if", "(", "IsVarArg", ")", "return", "CC_VE2", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "return", "CC_VE_C", ";", "case", "CallingConv", "::", "Fast", ":", "return", "CC_VE_Fast", ";", "}" ]

[ "}" ]

[ "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NewOpc", ")", ")", ".", "addOperand", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addOperand", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "Value", ")", ";", "(", "void", ")", "MIB", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Creating post-indexed load/store.", "<STR_LIT>", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Replacing instructions:\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "I", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "DEBUG", "(", "Update", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " with instruction:\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "(", "(", "MachineInstr", "*", ")", "MIB", ")", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "Update", "->", "eraseFromParent", "(", ")", ";", "return", "NextI", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "alpha_emit_conditional_move", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "I48MODE", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{" ]

[ "int", "immr", "=", "SrlImm", "-", "ShlImm", ";" ]

[ "Opd0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "{", "Opd0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "TruncBits", "=", "Opd0", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", "-", "VT", ".", "getSizeInBits", "(", ")", ";", "VT", "=", "Opd0", ".", "getValueType", "(", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "the promoted type should be i64", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "BiggerPattern", ")", "{", "Opd0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "return", "false", ";", "if", "(", "ShlImm", ">=", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "LLVM_DEBUG", "(", "(", "dbgs", "(", ")", "<<", "N", "<<", "<STR_LIT>", ": Found large shift immediate, this should not happen\\n", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "uint64_t", "SrlImm", "=", "<NUM_LIT>", ";", "if", "(", "!", "isIntImmediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "SrlImm", ")", ")", "return", "false", ";", "assert", "(", "SrlImm", ">", "<NUM_LIT>", "&&", "SrlImm", "<", "VT", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";" ]

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

[ "def", ":", "InstRW", "<", "[", "KryoWrite_4cyc_LS_X_X_296ln", "]", ",", "(", "instregex", "<STR_LIT>" ]

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

[ "(", "define_code_attr", "addsub", "[", "(" ]

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

[ "initializeFineIBTHashesSectionPass", "(", "*", "PassRegistry", "::", "getPassRegistry" ]

[ "static", "void", "pa_combine_instructions", "(", "void", ")", "{", "rtx_insn", "*", "anchor", ";", "if", "(", "optimize", "<", "<NUM_LIT>", ")", "return", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "NULL_RTX", ",", "NULL_RTX", ")", ")", ";", "rtx_insn", "*", "new", "_", "rtx", "=", "make_insn_raw", "(", "par", ")", ";", "for", "(", "anchor", "=", "get_insns", "(", ")", ";", "anchor", ";", "anchor", "=", "NEXT_INSN", "(", "anchor", ")", ")", "{", "enum", "attr_pa_combine_type", "anchor_attr", ";", "enum", "attr_pa_combine_type", "floater_attr", ";", "if", "(", "(", "!", "NONJUMP_INSN_P", "(", "anchor", ")", "&&", "!", "JUMP_P", "(", "anchor", ")", "&&", "!", "CALL_P", "(", "anchor", ")", ")", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "anchor", ")", ")", "==", "CLOBBER", ")", "continue", ";", "anchor_attr", "=", "get_attr_pa_combine_type", "(", "anchor", ")", ";", "if", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", "||", "anchor_attr", "==", "PA_COMBINE_TYPE_FADDSUB", "||", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_UNCOND_BRANCH", "&&", "!", "forward_branch_p", "(", "anchor", ")", ")", ")", "{", "rtx_insn", "*", "floater", ";", "for", "(", "floater", "=", "PREV_INSN", "(", "anchor", ")", ";", "floater", ";", "floater", "=", "PREV_INSN", "(", "floater", ")", ")", "{", "if", "(", "NOTE_P", "(", "floater", ")", "||", "(", "NONJUMP_INSN_P", "(", "floater", ")", "&&", "(", "GET_CODE", "(", "PATTERN", "(", "floater", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "floater", ")", ")", "==", "CLOBBER", ")", ")", ")", "continue", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "floater", ")", ")", "{", "floater", "=", "NULL", ";", "break", ";", "}", "floater_attr", "=", "get_attr_pa_combine_type", "(", "floater", ")", ";", "if", "(", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", "&&", "floater_attr", "==", "PA_COMBINE_TYPE_FADDSUB", ")", "||", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FADDSUB", "&&", "floater_attr", "==", "PA_COMBINE_TYPE_FMPY", ")", ")", "{", "if", "(", "pa_can_combine_p", "(", "new", "_", "rtx", ",", "anchor", ",", "floater", ",", "<NUM_LIT>", ",", "SET_DEST", "(", "PATTERN", "(", "floater", ")", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ")", ")", "break", ";", "}", "else", "if", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_UNCOND_BRANCH", "&&", "floater_attr", "==", "PA_COMBINE_TYPE_ADDMOVE", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ")", "==", "PLUS", ")", "{", "if", "(", "pa_can_combine_p", "(", "new", "_", "rtx", ",", "anchor", ",", "floater", ",", "<NUM_LIT>", ",", "SET_DEST", "(", "PATTERN", "(", "floater", ")", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ")", ")", "break", ";", "}", "else", "{", "if", "(", "pa_can_combine_p", "(", "new", "_", "rtx", ",", "anchor", ",", "floater", ",", "<NUM_LIT>", ",", "SET_DEST", "(", "PATTERN", "(", "floater", ")", ")", ",", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ")", ")", "break", ";", "}", "}", "}", "if", "(", "!", "floater", "&&", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", "||", "anchor_attr", "==", "PA_COMBINE_TYPE_FADDSUB", ")", ")", "{", "for", "(", "floater", "=", "anchor", ";", "floater", ";", "floater", "=", "NEXT_INSN", "(", "floater", ")", ")", "{", "if", "(", "NOTE_P", "(", "floater", ")", "||", "(", "NONJUMP_INSN_P", "(", "floater", ")", "&&", "(", "GET_CODE", "(", "PATTERN", "(", "floater", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "floater", ")", ")", "==", "CLOBBER", ")", ")", ")", "continue", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "floater", ")", ")", "{", "floater", "=", "NULL", ";", "break", ";", "}", "floater_attr", "=", "get_attr_pa_combine_type", "(", "floater", ")", ";", "if", "(", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", "&&", "floater_attr", "==", "PA_COMBINE_TYPE_FADDSUB", ")", "||", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FADDSUB", "&&", "floater_attr", "==", "PA_COMBINE_TYPE_FMPY", ")", ")", "{", "if", "(", "pa_can_combine_p", "(", "new", "_", "rtx", ",", "anchor", ",", "floater", ",", "<NUM_LIT>", ",", "SET_DEST", "(", "PATTERN", "(", "floater", ")", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "floater", ")", ")", ",", "<NUM_LIT>", ")", ")", ")", "break", ";", "}", "}", "}", "if", "(", "floater", "&&", "(", "anchor_attr", "==", "PA_COMBINE_TYPE_FADDSUB", "||", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", ")", ")", "{", "rtvec", "vtemp", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "copy_rtx", "(", "PATTERN", "(", "anchor", ")", ")", ",", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ")", ";", "rtx", "temp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vtemp", ")", ";", "emit_insn_before", "(", "temp", ",", "anchor", ")", ";", "SET_INSN_DELETED", "(", "anchor", ")", ";", "temp", "=", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ";", "emit_insn_before", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "temp", ")", ",", "floater", ")", ";", "delete", "_", "insn", "(", "floater", ")", ";", "continue", ";", "}", "else", "if", "(", "floater", "&&", "anchor_attr", "==", "PA_COMBINE_TYPE_UNCOND_BRANCH", ")", "{", "rtvec", "vtemp", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "copy_rtx", "(", "PATTERN", "(", "anchor", ")", ")", ",", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ")", ";", "rtx", "temp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vtemp", ")", ";", "temp", "=", "emit_jump_insn_before", "(", "temp", ",", "anchor", ")", ";", "JUMP_LABEL", "(", "temp", ")", "=", "JUMP_LABEL", "(", "anchor", ")", ";", "SET_INSN_DELETED", "(", "anchor", ")", ";", "temp", "=", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ";", "emit_insn_before", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "temp", ")", ",", "floater", ")", ";", "delete", "_", "insn", "(", "floater", ")", ";", "continue", ";", "}", "}", "}", "}" ]

[ "The", "PA", "has", "a", "number", "of", "odd", "instructions", "which", "can", "perform", "multiple", "tasks", "at", "once", ".", "On", "first", "generation", "PA", "machines", "(", "PA1.0", "and", "PA1.1", ")", "it", "may", "be", "profitable", "to", "combine", "two", "instructions", "into", "one", "instruction", "with", "two", "outputs", ".", "It", "'s", "not", "profitable", "PA2.0", "machines", "because", "the", "two", "outputs", "would", "take", "two", "slots", "in", "the", "reorder", "buffers", ".", "This", "routine", "finds", "instructions", "which", "can", "be", "combined", "and", "combines", "them", ".", "We", "only", "support", "some", "of", "the", "potential", "combinations", ",", "and", "we", "only", "try", "common", "ways", "to", "find", "suitable", "instructions", ".", "*", "addb", "can", "add", "two", "registers", "or", "a", "register", "and", "a", "small", "integer", "and", "jump", "to", "a", "nearby", "(", "+-8k", ")", "location", ".", "Normally", "the", "jump", "to", "the", "nearby", "location", "is", "conditional", "on", "the", "result", "of", "the", "add", ",", "but", "by", "using", "the", "``", "true", "''", "condition", "we", "can", "make", "the", "jump", "unconditional", ".", "Thus", "addb", "can", "perform", "two", "independent", "operations", "in", "one", "insn", ".", "*", "movb", "is", "similar", "to", "addb", "in", "that", "it", "can", "perform", "a", "reg-", ">", "reg", "or", "small", "immediate-", ">", "reg", "copy", "and", "jump", "to", "a", "nearby", "(", "+-8k", "location", ")", ".", "*", "fmpyadd", "and", "fmpysub", "can", "perform", "a", "FP", "multiply", "and", "either", "an", "FP", "add", "or", "FP", "sub", "if", "the", "operands", "of", "the", "multiply", "and", "add/sub", "are", "independent", "(", "there", "are", "other", "minor", "restrictions", ")", ".", "Note", "both", "the", "fmpy", "and", "fadd/fsub", "can", "in", "theory", "move", "to", "better", "spots", "according", "to", "data", "dependencies", ",", "but", "for", "now", "we", "require", "the", "fmpy", "stay", "at", "a", "fixed", "location", ".", "*", "Many", "of", "the", "memory", "operations", "can", "perform", "pre", "&", "post", "updates", "of", "index", "registers", ".", "GCC", "'s", "pre/post", "increment/decrement", "addressing", "is", "far", "too", "simple", "to", "take", "advantage", "of", "all", "the", "possibilities", ".", "This", "pass", "may", "not", "be", "suitable", "since", "those", "insns", "may", "not", "be", "independent", ".", "*", "comclr", "can", "compare", "two", "ints", "or", "an", "int", "and", "a", "register", ",", "nullify", "the", "following", "instruction", "and", "zero", "some", "other", "register", ".", "This", "is", "more", "difficult", "to", "use", "as", "it", "'s", "harder", "to", "find", "an", "insn", "which", "will", "generate", "a", "comclr", "than", "finding", "something", "like", "an", "unconditional", "branch", ".", "(", "conditional", "moves", "&", "long", "branches", "create", "comclr", "insns", ")", ".", "*", "Most", "arithmetic", "operations", "can", "conditionally", "skip", "the", "next", "instruction", ".", "They", "can", "be", "viewed", "as", "``", "perform", "this", "operation", "and", "conditionally", "jump", "to", "this", "nearby", "location", "''", "(", "where", "nearby", "is", "an", "insns", "away", ")", ".", "These", "are", "difficult", "to", "use", "due", "to", "the", "branch", "length", "restrictions", "." ]

[ "if", "(", "EltSize", ">", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "if", "(", "CombineVLDDUP", "(", "N", ",", "DCI", ")", ")", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "while", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "Op", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Op", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "SDValue", "(", ")", ";", "unsigned", "EltSize", "=", "Op", ".", "getScalarValueSizeInBits", "(", ")", ";", "unsigned", "Imm", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "EltBits", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ",", "EltBits", ")", "==", "<NUM_LIT>", ")", "EltSize", "=", "<NUM_LIT>", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";" ]

[ ")", ";" ]

[ "dag", "InOperandList", "=", "(", "ins", "GPR32Opnd", ":", "$", "rs", ",", "uimm2", ":", "$", "bp", ",", "GPR32Opnd", ":", "$", "src", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "<STR_LIT>", ",", "<STR_LIT>" ]

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

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

[ "unsigned", "FromReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "bool", "CallReturnsInput", "=", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ";", "if", "(", "!", "CallReturnsInput", ")", "return", "false", ";", "LibFunc", "Func", ";", "if", "(", "!", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "return", "false", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "<", "vec_double", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "<", "vec_double", ">", "[", "(", "match_operand", ":", "VI_HW_QHS", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]