Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "case", "Hexagon", "::", "J2_callf", ":" ]

[ "return", "false", ";", "case", "Hexagon", "::", "J2_jump", ":", "case", "Hexagon", "::", "J2_call", ":", "case", "Hexagon", "::", "PS_call_nr", ":", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "offset", ")", ";", "case", "Hexagon", "::", "J2_jumpt", ":", "case", "Hexagon", "::", "J2_jumpf", ":", "case", "Hexagon", "::", "J2_jumptnew", ":", "case", "Hexagon", "::", "J2_jumptnewpt", ":", "case", "Hexagon", "::", "J2_jumpfnew", ":", "case", "Hexagon", "::", "J2_jumpfnewpt", ":", "case", "Hexagon", "::", "J2_callt", ":" ]

[ "}" ]

[ "def", "logical_imm32_not", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "LogicalImm32NotOperand", ";" ]

[ ")" ]

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_dup", "<NUM_LIT>" ]

[ "}" ]

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

[ ")", ";" ]

[ "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "GVA", "->", "getSection", "(", ")", ".", "startswith", "(", "<STR_LIT>", ".ldata", "<STR_LIT>", ")", ")", "return", "false", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ")", "return", "true", ";", "if", "(", "GVA", "->", "hasLocalLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "(", "(", "GVA", "->", "hasExternalLinkage", "(", ")", "&&", "GVA", "->", "isDeclaration", "(", ")", ")", "||", "GVA", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GVA", "->", "getValueType", "(" ]

[ "case", "VK_Sparc_TLS_LDM_HI22", ":", "OS", "<<", "<STR_LIT>", "%tldm_hi22(", "<STR_LIT>", ";", "break", ";" ]

[ "case", "VK_Sparc_HM", ":", "OS", "<<", "<STR_LIT>", "%hm(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_PC22", ":", "OS", "<<", "<STR_LIT>", "%hi(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_PC10", ":", "OS", "<<", "<STR_LIT>", "%lo(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_GOT22", ":", "OS", "<<", "<STR_LIT>", "%hi(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_GOT10", ":", "OS", "<<", "<STR_LIT>", "%lo(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_WPLT30", ":", "closeParen", "=", "false", ";", "break", ";", "case", "VK_Sparc_R_DISP32", ":", "OS", "<<", "<STR_LIT>", "%r_disp32(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_TLS_GD_HI22", ":", "OS", "<<", "<STR_LIT>", "%tgd_hi22(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_TLS_GD_LO10", ":", "OS", "<<", "<STR_LIT>", "%tgd_lo10(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_TLS_GD_ADD", ":", "OS", "<<", "<STR_LIT>", "%tgd_add(", "<STR_LIT>", ";", "break", ";", "case", "VK_Sparc_TLS_GD_CALL", ":", "OS", "<<", "<STR_LIT>", "%tgd_call(", "<STR_LIT>", ";", "break", ";" ]

[ ")" ]

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

[ "return", "TIDReg", ";", "}" ]

[ "unsigned", "getTIDReg", "(", ")", "const", "{" ]

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

[ "<NUM_LIT>", ";" ]

[ "class", "StoreInst_EVENT", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "DAGOperand", "Src", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "StoreInstGenericSrcA", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", "Src", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "SPred", ":", "$", "pred", ")", ";", "let", "HasImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src", ")", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_LoadComplexOp", ";", "let", "isNotUsedInDisasm", "=" ]

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

[ "def", "NEONvqshrnsu", ":", "SDNode", "<", "<STR_LIT>", "," ]

[ ">", ";" ]

[ "def", "vfsetoge_v2f64", ":", "vfsetcc_type", "<", "v2i64", ",", "v2f64", ",", "SETOGE" ]

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

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

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

[ "def", "Y", ":", "StoreSIY", "<", "mnemonic", "#", "<STR_LIT>", ",", "siyOpcode", ",", "operator", "," ]

[ "void", "WebAssemblyMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "uint64_t", "Start", "=", "OS", ".", "tell", "(", ")", ";", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "Binary", "<=", "UINT8_MAX", ")", "{", "OS", "<<", "uint8_t", "(", "Binary", ")", ";", "}", "else", "{", "assert", "(", "Binary", "<=", "UINT16_MAX", "&&", "<STR_LIT>", "Several-byte opcodes not supported yet", "<STR_LIT>", ")", ";", "OS", "<<", "uint8_t", "(", "Binary", ">>", "<NUM_LIT>", ")", ";", "encodeULEB128", "(", "uint8_t", "(", "Binary", ")", ",", "OS", ")", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I32_S", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I64_S", ")", "encodeULEB128", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ",", "OS", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I32", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "BR_TABLE_I64", ")", "encodeULEB128", "(", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "if", "(", "I", "<", "Desc", ".", "getNumOperands", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Encoding immediate: type=", "<STR_LIT>", "<<", "int", "(", "Info", ".", "OperandType", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "switch", "(", "Info", ".", "OperandType", ")", "{", "case", "WebAssembly", "::", "OPERAND_I32IMM", ":", "encodeSLEB128", "(", "int32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_OFFSET32", ":", "encodeULEB128", "(", "uint32_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_I64IMM", ":", "encodeSLEB128", "(", "int64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_SIGNATURE", ":", "OS", "<<", "uint8_t", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I8IMM", ":", "support", "::", "endian", "::", "write", "<", "uint8_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I16IMM", ":", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I32IMM", ":", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_VEC_I64IMM", ":", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "OS", ",", "MO", ".", "getImm", "(", ")", ",", "support", "::", "little", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_GLOBAL", ":", "llvm_unreachable", "(", "<STR_LIT>", "wasm globals should only be accessed symbolicly", "<STR_LIT>", ")", ";", "default", ":", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "{", "encodeULEB128", "(", "uint64_t", "(", "MO", ".", "getImm", "(", ")", ")", ",", "OS", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F32IMM", ")", "{", "auto", "F", "=", "float", "(", "MO", ".", "getFPImm", "(", ")", ")", ";", "support", "::", "endian", "::", "write", "<", "float", ">", "(", "OS", ",", "F", ",", "support", "::", "little", ")", ";", "}", "else", "{", "assert", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F64IMM", ")", ";", "double", "D", "=", "MO", ".", "getFPImm", "(", ")", ";", "support", "::", "endian", "::", "write", "<", "double", ">", "(", "OS", ",", "D", ",", "support", "::", "little", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "I", "]", ";", "llvm", "::", "MCFixupKind", "FixupKind", ";", "size_t", "PaddedSize", "=", "<NUM_LIT>", ";", "switch", "(", "Info", ".", "OperandType", ")", "{", "case", "WebAssembly", "::", "OPERAND_I32IMM", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_sleb128_i32", ")", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_I64IMM", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_sleb128_i64", ")", ";", "PaddedSize", "=", "<NUM_LIT>", ";", "break", ";", "case", "WebAssembly", "::", "OPERAND_FUNCTION32", ":", "case", "WebAssembly", "::", "OPERAND_OFFSET32", ":", "case", "WebAssembly", "::", "OPERAND_TYPEINDEX", ":", "case", "WebAssembly", "::", "OPERAND_GLOBAL", ":", "case", "WebAssembly", "::", "OPERAND_EVENT", ":", "FixupKind", "=", "MCFixupKind", "(", "WebAssembly", "::", "fixup_code_uleb128_i32", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected symbolic operand kind", "<STR_LIT>", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "OS", ".", "tell", "(", ")", "-", "Start", ",", "MO", ".", "getExpr", "(", ")", ",", "FixupKind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "encodeULEB128", "(", "<NUM_LIT>", ",", "OS", ",", "PaddedSize", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "unexpected operand kind", "<STR_LIT>", ")", ";", "}", "}", "++", "MCNumEmitted", ";", "}" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

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

[ "def", "C2_cmpgei", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s8_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56f114f4", ",", "TypeALU32_2op", ">", "{", "let", "isCompare", "=", "<NUM_LIT>", ";" ]

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

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

[ "enum", "attr_fp_mode", "norm_mode", "=", "ACTUAL_NORMAL_MODE", "(", "FP_MODE", ")", ";" ]

[ "void", "fpscr_set_from_mem", "(", "int", "mode", ",", "HARD_REG_SET", "regs_live", ")", "{", "enum", "attr_fp_mode", "fp_mode", "=", "(", "enum", "attr_fp_mode", ")", "mode", ";" ]

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

[ "def", "v16i8", ":", "BaseSIMDThreeSameVectorDot", "<", "<NUM_LIT>", ",", "U", ",", "Mixed", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "V128", ",", "v4i32", ",", "v16i8" ]

[ "<FIXS>", "ENUM_ENTRY", "(", "ATTR_OPSIZE", ",", "<NUM_LIT>", ")", "\\", "ENUM_ENTRY", "(", "ATTR_VEX", ",", "<NUM_LIT>", ")", "\\", "ENUM_ENTRY", "(", "ATTR_VEXL", ",", "<NUM_LIT>", ")", "<FIXE>" ]

[ "ENUM_ENTRY", "(", "ATTR_XS", ",", "<NUM_LIT>", ")", "\\", "ENUM_ENTRY", "(", "ATTR_XD", ",", "<NUM_LIT>", ")", "\\", "ENUM_ENTRY", "(", "ATTR_REXW", ",", "<NUM_LIT>", ")", "\\", "<BUGS>", "ENUM_ENTRY", "(", "ATTR_OPSIZE", ",", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "ENUM_ENTRY", "(", "n", ",", "v", ")", "n", "=", "v", ",", "enum", "attributeBits", "{" ]

[ "(", "fix", ":", "DI", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

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

[ "break", ";" ]

[ "case", "GT", ":", "compare_code", "=", "LT", ";", "branch_code", "=", "NE", ";", "must_swap", "=", "<NUM_LIT>", ";", "break", ";", "case", "GE", ":", "compare_code", "=", "LT", ";", "branch_code", "=", "EQ", ";", "break", ";", "case", "LTU", ":", "compare_code", "=", "LTU", ";", "branch_code", "=", "NE", ";", "break", ";", "case", "LEU", ":", "compare_code", "=", "LTU", ";", "branch_code", "=", "EQ", ";", "must_swap", "=", "<NUM_LIT>", ";", "break", ";", "case", "GTU", ":", "compare_code", "=", "LTU", ";", "branch_code", "=", "NE", ";", "must_swap", "=", "<NUM_LIT>", ";", "break", ";", "case", "GEU", ":", "compare_code", "=", "LTU", ";", "branch_code", "=", "EQ", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "need_compare", ")", "{", "switch", "(", "compare_code", ")", "{", "case", "EQ", ":", "if", "(", "GET_CODE", "(", "y", ")", "==", "CONST_INT", "&&", "CMP_INT16_P", "(", "INTVAL", "(", "y", ")", ")", "&&", "y", "!=", "const0_rtx", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "tmp", ",", "x", ",", "GEN_INT", "(", "-", "INTVAL", "(", "y", ")", ")", ")", ")", ";", "x", "=", "tmp", ";", "y", "=", "const0_rtx", ";", "}", "else", "if", "(", "CONSTANT_P", "(", "y", ")", ")", "{", "rtx", "tmp", "=", "force_reg", "(", "GET_MODE", "(", "x", ")", ",", "y", ")", ";", "y", "=", "tmp", ";", "}", "if", "(", "register_operand", "(", "y", ",", "SImode", ")", "||", "y", "==", "const0_rtx", ")", "{", "emit_insn", "(", "gen_cmp_eqsi_insn", "(", "x", ",", "y", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "CCmode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "break", ";", "case", "LT", ":", "if", "(", "register_operand", "(", "y", ",", "SImode", ")", "||", "(", "GET_CODE", "(", "y", ")", "==", "CONST_INT", "&&", "CMP_INT16_P", "(", "INTVAL", "(", "y", ")", ")", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "LT", ":", "emit_insn", "(", "gen_cmp_ltsi_insn", "(", "x", ",", "y", ")", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "LE", ":", "if", "(", "y", "==", "const0_rtx", ")", "tmp", "=", "const1_rtx", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "tmp", ",", "y", ",", "constm1_rtx", ")", ")", ";", "emit_insn", "(", "gen_cmp_ltsi_insn", "(", "x", ",", "tmp", ")", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GT", ":", "if", "(", "GET_CODE", "(", "y", ")", "==", "CONST_INT", ")", "tmp", "=", "gen_rtx_PLUS", "(", "SImode", ",", "y", ",", "const1_rtx", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "tmp", ",", "y", ",", "constm1_rtx", ")", ")", ";", "emit_insn", "(", "gen_cmp_ltsi_insn", "(", "x", ",", "tmp", ")", ")", ";", "code", "=", "NE", ";", "break", ";", "case", "GE", ":", "emit_insn", "(", "gen_cmp_ltsi_insn", "(", "x", ",", "y", ")", ")", ";", "code", "=", "NE", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "CCmode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "break", ";", "case", "LTU", ":", "if", "(", "register_operand", "(", "y", ",", "SImode", ")", "||", "(", "GET_CODE", "(", "y", ")", "==", "CONST_INT", "&&", "CMP_INT16_P", "(", "INTVAL", "(", "y", ")", ")", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "LTU", ":", "emit_insn", "(", "gen_cmp_ltusi_insn", "(", "x", ",", "y", ")", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "LEU", ":", "if", "(", "y", "==", "const0_rtx", ")", "tmp", "=", "const1_rtx", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "tmp", ",", "y", ",", "constm1_rtx", ")", ")", ";", "emit_insn", "(", "gen_cmp_ltusi_insn", "(", "x", ",", "tmp", ")", ")", ";", "code", "=", "EQ", ";" ]

[ ".", "base", "&&", "!", "address", ".", "offset", "&&", "!", "address", ".", "index", ")", ";" ]

[ "return", "(", "m68k_legitimate_mem_p", "(", "x", ",", "&", "address", ")", "&&", "address", ".", "code", "==", "UNKNOWN", "&&", "address" ]

[ "}" ]

[ "void", "ARM64InstPrinter", "::", "printMemoryRegOffset8", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNum", ",", "raw_ostream", "&", "O", ")", "{", "printMemoryRegOffset", "(", "MI", ",", "OpNum", ",", "O", ",", "<NUM_LIT>", ")", ";" ]

[ "void", "MipsInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "RC", "==", "Mips", "::", "CPURegsRegisterClass", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "SW_P8", ":", "Mips", "::", "SW", ";", "else", "if", "(", "RC", "==", "Mips", "::", "CPU64RegsRegisterClass", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "SD_P8", ":", "Mips", "::", "SD", ";", "else", "if", "(", "RC", "==", "Mips", "::", "FGR32RegisterClass", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "SWC1_P8", ":", "Mips", "::", "SWC1", ";", "else", "if", "(", "RC", "==", "Mips", "::", "AFGR64RegisterClass", ")", "Opc", "=", "Mips", "::", "SDC1", ";", "else", "if", "(", "RC", "==", "Mips", "::", "FGR64RegisterClass", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "SDC164_P8", ":", "Mips", "::", "SDC164", ";", "assert", "(", "Opc", "&&", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}" ]

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

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

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

[ "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg" ]

[ "}" ]

[ "VECC", ":", ":", "CondCode", "VECC", "=", "intCondCode2Icc", "(", "CC", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "VECC", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "fcond2cc", ":", "SDNodeXForm", "<", "cond", ",", "[", "{", "VECC", ":", ":", "CondCode", "VECC", "=", "fpCondCode2Fcc", "(", "N", "-", ">", "get", "(", ")", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "VECC", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "fcond2ccSwap", ":", "SDNodeXForm", "<", "cond", ",", "[", "{", "ISD", ":", ":", "CondCode", "CC", "=", "getSetCCSwappedOperands", "(", "N", "-", ">", "get", "(", ")", ")", ";", "VECC", ":", ":", "CondCode", "VECC", "=", "fpCondCode2Fcc", "(", "CC", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "VECC", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "CCOP", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getZExtValue", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "ZeroAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";" ]

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

[ "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "int32_t", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "<NUM_LIT>", ")", "{", "MFI", "->", "CreateFixedObject", "(", "-", "TailCallReturnAddrDelta", ",", "(", "-", "<NUM_LIT>", "U", "*", "SlotSize", ")", "+", "TailCallReturnAddrDelta", ",", "true", ")", ";", "}", "if", "(", "hasFP", "(", "MF" ]

[ "if", "(", "BitCastOperator", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "FindUses", "(", "BC", ",", "F", ",", "Uses", ",", "ConstantBCs", ")", ";" ]

[ "static", "void", "FindUses", "(", "Value", "*", "V", ",", "Function", "&", "F", ",", "SmallVectorImpl", "<", "std", "::", "pair", "<", "Use", "*", ",", "Function", "*", ">>", "&", "Uses", ",", "SmallPtrSetImpl", "<", "Constant", "*", ">", "&", "ConstantBCs", ")", "{", "for", "(", "Use", "&", "U", ":", "V", "->", "uses", "(", ")", ")", "{" ]

[ "VPR128", ":", "$", "Rn", ")", ",", "OpLImm", ":", "$", "Imm", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "ResTy", "(", "Neon_vduplane", "(", "OpTy", "VPR128", ":", "$", "Rn", ")", ",", "OpLImm", ":", "$", "Imm", ")", ")", ",", "(", "ResTy", "(", "DUPELT", "(", "OpTy" ]

[ "}", ")" ]

[ "(", "match_code", "<STR_LIT>", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "=", "=", "IOR", ")" ]

[ "}" ]

[ "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown operand type", "<STR_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "<STR_LIT>", "Subregs should be eliminated!", "<STR_LIT>", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "if", "(", "Subtarget", "->", "genExecuteOnly", "(", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "execute-only should not generate constant pools", "<STR_LIT>", ")", ";", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "createDFPImm", "(", "bit_cast", "<", "uint64_t", ">", "(", "Val", ".", "convertToDouble", "(", ")", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";" ]

[ ";" ]

[ "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "get_some_local_dynamic_name_1", ",", "<NUM_LIT>", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")" ]

[ ")", ";" ]

[ "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_and", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_AND", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_or", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_or", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_OR", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_xor", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_xor", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_XOR", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_inc", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_INC", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_dec", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_DEC", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_cmpswap", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_cmpswap", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_CMPSWAP", ";", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_fadd", ":", "return", "AMDGPU", "::", "G_AMDGPU_BUFFER_ATOMIC_FADD", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unhandled atomic opcode", "<STR_LIT>" ]

[ "static", "void", "csky_output_constpool_label", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "char", "buf", "[", "<NUM_LIT>", "]", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ";", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "VUNSPEC_POOL_LABEL", ")", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "CSKY_CONSTPOOL_LABEL_PREFIX", ",", "INTVAL", "(", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "assemble_name", "(", "stream", ",", "buf", ")", ";", "}", "}" ]

[ "Output", "the", "constpool", "label", "according", "to", "the", "rtx", "expression", "X", "." ]

[ ";" ]

[ "SDVTList", "NewVTList", "=", "HasChain", "?", "DAG", ".", "getVTList", "(", "ResultVT", ",", "MVT", "::", "Other", ")", ":", "DAG", ".", "getVTList", "(", "ResultVT", ")", ";", "MachineSDNode", "*", "NewNode", "=", "DAG", ".", "getMachineNode", "(", "NewOpcode", ",", "SDLoc", "(", "Node", ")", ",", "NewVTList", ",", "Ops", ")", ";", "if", "(", "HasChain", ")", "{", "DAG", ".", "setNodeMemRefs", "(", "NewNode", ",", "Node", "->", "memoperands", "(", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "Node", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewNode", ",", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "NewChannels", "==", "<NUM_LIT>", ")", "{", "assert", "(", "Node", "->", "hasNUsesOfValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "SDNode", "*", "Copy", "=", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "COPY", ",", "SDLoc", "(", "Node", ")", ",", "Users", "[", "Lane", "]", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "SDValue", "(", "NewNode", ",", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "Users", "[", "Lane", "]", ",", "Copy", ")", ";", "return", "nullptr", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "Idx", "=", "AMDGPU", "::", "sub0", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "SDNode", "*", "User", "=", "Users", "[", "i", "]", ";", "if", "(", "!", "User", ")", "{", "if", "(", "i", "||", "!", "NoChannels", ")", "continue", ";", "}", "else", "{", "SDValue", "Op", "=", "DAG", ".", "getTargetConstant", "(", "Idx", ",", "SDLoc", "(", "User", ")", ",", "MVT", "::", "i32", ")", ";", "DAG", ".", "UpdateNodeOperands", "(", "User", ",", "SDValue", "(", "NewNode", ",", "<NUM_LIT>", ")", ",", "Op", ")", ";", "}", "switch", "(", "Idx", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "sub0", ":", "Idx", "=", "AMDGPU", "::", "sub1", ";", "break", ";", "case", "AMDGPU", "::", "sub1", ":", "Idx", "=", "AMDGPU", "::", "sub2", ";", "break", ";", "case", "AMDGPU", "::", "sub2", ":", "Idx", "=", "AMDGPU", "::", "sub3", ";", "break", ";", "case", "AMDGPU", "::", "sub3", ":", "Idx", "=", "AMDGPU", "::", "sub4", ";", "break", ";", "}", "}", "DAG", ".", "RemoveDeadNode", "(", "Node", ")", ";", "return", "nullptr" ]

[ "}" ]

[ "bool", "X86TargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "Opc", "==", "ISD", "::", "SHL", "&&", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", ")", "return", "false", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", ")", "return", "true", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "true", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "false", ";" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ "emit_insn", "(", "gen_strlenqi_1", "(", "scratch1", ",", "scratch3", ",", "unspec", ")", ")", ";" ]

[ "rtx", "addr", ",", "scratch1", ",", "scratch2", ",", "scratch3", ",", "scratch4", ";", "if", "(", "TARGET_UNROLL_STRLEN", "&&", "eoschar", "==", "const0_rtx", "&&", "optimize", ">", "<NUM_LIT>", "&&", "!", "TARGET_INLINE_ALL_STRINGOPS", "&&", "!", "optimize_insn_for_size_p", "(", ")", "&&", "(", "!", "CONST_INT_P", "(", "align", ")", "||", "INTVAL", "(", "align", ")", "<", "<NUM_LIT>", ")", ")", "return", "false", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ";", "scratch1", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_UNROLL_STRLEN", "&&", "eoschar", "==", "const0_rtx", "&&", "optimize", ">", "<NUM_LIT>", "&&", "!", "optimize_insn_for_size_p", "(", ")", ")", "{", "emit_move_insn", "(", "out", ",", "addr", ")", ";", "ix86_expand_strlensi_unroll_1", "(", "out", ",", "src", ",", "align", ")", ";", "emit_insn", "(", "ix86_gen_sub3", "(", "out", ",", "out", ",", "addr", ")", ")", ";", "}", "else", "{", "rtx", "unspec", ";", "if", "(", "fixed_regs", "[", "AX_REG", "]", "||", "fixed_regs", "[", "CX_REG", "]", "||", "fixed_regs", "[", "DI_REG", "]", ")", "return", "false", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "MEM_ADDR_SPACE", "(", "src", ")", ")", ")", "return", "false", ";", "scratch2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "scratch3", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "scratch4", "=", "force_reg", "(", "Pmode", ",", "constm1_rtx", ")", ";", "emit_move_insn", "(", "scratch3", ",", "addr", ")", ";", "eoschar", "=", "force_reg", "(", "QImode", ",", "eoschar", ")", ";", "src", "=", "replace_equiv_address_nv", "(", "src", ",", "scratch3", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "src", ",", "eoschar", ",", "align", ",", "scratch4", ")", ",", "UNSPEC_SCAS", ")", ";" ]

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

[ "bool", "ARMFastISel", "::", "ARMEmitLibcall", "(", "const", "Instruction", "*", "I", ",", "RTLIB", "::", "Libcall", "Call", ")", "{", "CallingConv", "::", "ID", "CC", "=", "TLI", ".", "getLibcallCallingConv", "(", "Call", ")", ";", "Type", "*", "RetTy", "=", "I", "->", "getType", "(", ")", ";", "MVT", "RetVT", ";", "if", "(", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeLegal", "(", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "if", "(", "EnableARMLongCalls", ")", "return", "false", ";", "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "Args", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "ArgRegs", ";", "SmallVector", "<", "MVT", ",", "<NUM_LIT>", ">", "ArgVTs", ";", "SmallVector", "<", "ISD", "::", "ArgFlagsTy", ",", "<NUM_LIT>", ">", "ArgFlags", ";", "Args", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "ArgRegs", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "ArgVTs", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "ArgFlags", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "I", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "Value", "*", "Op", "=", "I", "->", "getOperand", "(", "i", ")", ";", "unsigned", "Arg", "=", "getRegForValue", "(", "Op", ")", ";", "if", "(", "Arg", "==", "<NUM_LIT>", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Op", "->", "getType", "(", ")", ";", "MVT", "ArgVT", ";", "if", "(", "!", "isTypeLegal", "(", "ArgTy", ",", "ArgVT", ")", ")", "return", "false", ";", "ISD", "::", "ArgFlagsTy", "Flags", ";", "unsigned", "OriginalAlignment", "=", "TD", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "Args", ".", "push_back", "(", "Op", ")", ";", "ArgRegs", ".", "push_back", "(", "Arg", ")", ";", "ArgVTs", ".", "push_back", "(", "ArgVT", ")", ";", "ArgFlags", ".", "push_back", "(", "Flags", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RegArgs", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "ProcessCallArgs", "(", "Args", ",", "ArgRegs", ",", "ArgVTs", ",", "ArgFlags", ",", "RegArgs", ",", "CC", ",", "NumBytes", ")", ")", "return", "false", ";", "MachineInstrBuilder", "MIB", ";", "unsigned", "CallOpc", "=", "ARMSelectCallOp", "(", "NULL", ")", ";", "if", "(", "isThumb2", ")", "MIB", "=", "AddDefaultPred", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "CallOpc", ")", ")", ")", ".", "addExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "Call", ")", ")", ";", "else", "MIB", "=", "AddDefaultPred", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "CallOpc", ")", ")", ".", "addExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "Call", ")", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegArgs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addReg", "(", "RegArgs", "[" ]

[ "<FIXS>", "defm", "VPINSRB", ":", "SS41I_insert8", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ">", ",", "VEX", ",", "VVVV", ",", "WIG", ";", "<FIXE>" ]

[ "}", "let", "Predicates", "=", "[", "HasAVX", ",", "NoBWI", "]", "in", "{", "<BUGS>", "defm", "VPINSRB", ":", "SS41I_insert8", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ">", ",", "VEX_4V", ",", "WIG", ";", "<BUGE>", "def", ":", "Pat", "(", "X86pinsrb", "VR128", ":", "$", "src1", ",", "(", "i32", "(", "anyext", "(", "i8", "GR8", ":", "$", "src2", ")", ")", ")", ",", "timm", ":", "$", "src3", ")", ",", "(", "VPINSRBrr", "VR128", ":", "$", "src1", ",", "(", "INSERT_SUBREG", "(", "i32", "(", "IMPLICIT_DEF", ")", ")", ",", "GR8", ":", "$", "src2", ",", "sub_8bit", ")", ",", "timm", ":", "$", "src3", ")", ">", ";" ]

[ ";", "++", "i", ")", "{" ]

[ "assert", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "Root", ".", "getSimpleValueType", "(", ")", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "Can only combine shuffles of the same vector register size.", "<STR_LIT>", ")", ";", "SDValue", "Input0", ",", "Input1", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "OpMask", ";", "if", "(", "!", "resolveTargetShuffleInputs", "(", "Op", ",", "Input0", ",", "Input1", ",", "OpMask", ")", ")", "return", "false", ";", "assert", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "OpMask", ".", "size", "(", ")", "&&", "<STR_LIT>", "Different mask size from vector size!", "<STR_LIT>", ")", ";", "assert", "(", "(", "(", "RootMask", ".", "size", "(", ")", ">", "OpMask", ".", "size", "(", ")", "&&", "RootMask", ".", "size", "(", ")", "%", "OpMask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "||", "(", "OpMask", ".", "size", "(", ")", ">", "RootMask", ".", "size", "(", ")", "&&", "OpMask", ".", "size", "(", ")", "%", "RootMask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "||", "OpMask", ".", "size", "(", ")", "==", "RootMask", ".", "size", "(", ")", ")", "&&", "<STR_LIT>", "The smaller number of elements must divide the larger.", "<STR_LIT>", ")", ";", "int", "MaskWidth", "=", "std", "::", "max", "<", "int", ">", "(", "OpMask", ".", "size", "(", ")", ",", "RootMask", ".", "size", "(", ")", ")", ";", "int", "RootRatio", "=", "std", "::", "max", "<", "int", ">", "(", "<NUM_LIT>", ",", "OpMask", ".", "size", "(", ")", "/", "RootMask", ".", "size", "(", ")", ")", ";", "int", "OpRatio", "=", "std", "::", "max", "<", "int", ">", "(", "<NUM_LIT>", ",", "RootMask", ".", "size", "(", ")", "/", "OpMask", ".", "size", "(", ")", ")", ";", "assert", "(", "(", "(", "RootRatio", "==", "<NUM_LIT>", "&&", "OpRatio", "==", "<NUM_LIT>", ")", "||", "(", "RootRatio", "==", "<NUM_LIT>", ")", "!=", "(", "OpRatio", "==", "<NUM_LIT>", ")", ")", "&&", "<STR_LIT>", "Must not have a ratio for both incoming and op masks!", "<STR_LIT>", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", ";", "Mask", ".", "reserve", "(", "MaskWidth", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "MaskWidth" ]

[ "$", "QnSrc", ",", "MQPR", ":", "$", "QmSrc", ",", "vpred_r", ":", "$", "vp", ")", ">", ";" ]

[ "def", ":", "MVEInstAlias", "<", "<STR_LIT>", "#", "s", "#", "<STR_LIT>", ",", "(", "MVE_VORR", "MQPR", ":", "$", "QdSrc", ",", "MQPR", ":" ]

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

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

[ "_", "a", ",", "mve_pred16_t", "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vrev64q_m_s16", "(", "int16x8_t", "_", "_", "inactive", ",", "int16x8_t", "_" ]

[ "}" ]

[ "class", "SOPK_SCC", "<", "string", "opName", ",", "string", "base_op", ",", "bit", "isSignExt", ">", ":", "SOPK_Pseudo", "<", "opName", ",", "(", "outs", ")", ",", "!", "if", "(", "isSignExt", ",", "(", "ins", "SReg_32", ":", "$", "sdst", ",", "s16imm", ":", "$", "simm16", ")", ",", "(", "ins", "SReg_32", ":", "$", "sdst", ",", "u16imm", ":", "$", "simm16", ")", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "SOPKInstTable", "<", "<NUM_LIT>", ",", "base_op", ">", "{", "let", "Defs", "=", "[", "SCC", "]", ";" ]

[ "rtx", "gen_df_reg", "(", "rtx", "reg", ",", "int", "low", ")", "{", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "(", "WORDS_BIG_ENDIAN", "==", "<NUM_LIT>", ")", "^", "(", "low", "!=", "<NUM_LIT>", ")", ")", "regno", "+=", "(", "TARGET_ARCH64", "&&", "regno", "<", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "}" ]

[ "Generate", "a", "DFmode", "part", "of", "a", "hard", "TFmode", "register", ".", "REG", "is", "the", "TFmode", "hard", "register", ",", "LOW", "is", "1", "for", "the", "low", "64bit", "of", "the", "register", "and", "0", "otherwise", "." ]

[ "bool", "IsComplex", ")", "const", "{" ]

[ "unsigned", "AArch64TTI", "::", "getAddressComputationCost", "(", "Type", "*", "Ty", "," ]

[ "}" ]

[ "void", "LanaiTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sdata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sbss", "<STR_LIT>", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";" ]

[ "<FIXS>", "#", "include", "<STR_LIT>", "llvm/ADT/SmallSet.h", "<STR_LIT>", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Target/TargetOptions.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "X86MachineFunctionInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "X86Subtarget.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "X86TargetMachine.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/Function.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineFrameInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineFunction.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineInstrBuilder.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineModuleInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineRegisterInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/MC/MCAsmInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/MC/MCSymbol.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/DataLayout.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Target/TargetOptions.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "llvm/Support/CommandLine.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/ADT/SmallSet.h", "<STR_LIT>", "<BUGE>", "using", "namespace", "llvm", ";" ]

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

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

[ ";" ]

[ "if", "(", "Filename", ".", "empty", "(", ")", ")", "return", "false", ";", "LLVMContext", "&", "Ctx", "=", "M", ".", "getContext", "(", ")", ";", "ErrorOr", "<", "std", "::", "unique_ptr", "<", "SampleProfileReader", ">>", "ReaderOrErr", "=", "SampleProfileReader", "::", "create", "(", "Filename", ",", "Ctx", ")", ";", "if", "(", "std", "::", "error_code", "EC", "=", "ReaderOrErr", ".", "getError", "(", ")", ")", "{", "std", "::", "string", "Msg", "=", "<STR_LIT>", "Could not open profile: ", "<STR_LIT>", "+", "EC", ".", "message", "(", ")", ";", "Ctx", ".", "diagnose", "(", "DiagnosticInfoSampleProfile", "(", "Filename", ",", "Msg", ",", "DiagnosticSeverity", "::", "DS_Warning", ")", ")", ";", "return", "false" ]

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

[ "class", "BaseCondSelect", "<", "bit", "op", ",", "bits", "<", "<NUM_LIT>", ">", "op2", ",", "RegisterClass", "regtype", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "ccode", ":", "$", "cond", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "ARM64csel", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "(", "i32", "imm", ":", "$", "cond", ")", ",", "CPSR", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteI", "]", ">", "{", "let", "Uses", "=", "[", "CPSR", "]", ";" ]

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

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

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

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_loaddquqi512_mask", "(", "(", "const", "char", "*", ")", "_", "_", "P", ",", "(", "_", "_", "v64qi", ")", "_", "_", "W", ",", "(", "_", "_" ]

[ "<NUM_LIT>", ")" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_select", ":", "V8HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int" ]

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

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

[ "def", "v2i32_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V64", ",", "V64", ",", "V128", ",", "VectorIndexS", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i32", "V64", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "(", "v2i32", "(", "AArch64duplane32", "(", "v4i32", "V128", ":", "$", "Rm", ")", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "Encoding", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op0", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "crn", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "crm", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "bit", "Readable", "=", "?", ";", "bit", "Writeable", "=", "?", ";", "code", "Requires", "=", "[", "{", "{", "}", "}", "]", ";" ]

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

[ "let", "ParserMatchClass", "=", "MSRSystemRegisterOperand", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ ")", ";" ]

[ "MCInst", "tmpInst", ";", "if", "(", "PerformShift", ")", "{", "tmpInst", ".", "setOpcode", "(", "Mips", "::", "SLL", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "tmpInst", ".", "setLoc", "(", "IDLoc", ")", ";", "Instructions", ".", "push_back", "(", "tmpInst", ")", ";", "tmpInst", ".", "clear", "(", ")", ";", "}", "tmpInst", ".", "setOpcode", "(", "Mips", "::", "ORi", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";", "tmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")" ]

[ "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SRA", ")", ",", "DstReg", ")", ".", "addReg", "(", "ScrReg", ")", ".", "addImm", "(", "ShiftImm", ")", ";" ]

[ "return", "BB", ";", "}", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "MVT", "::", "i32", ")", ";", "unsigned", "ScrReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Size", "<", "<NUM_LIT>", ")", ";", "int64_t", "ShiftImm", "=", "<NUM_LIT>", "-", "(", "Size", "*", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLL", ")", ",", "ScrReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "ShiftImm", ")", ";" ]

[ "<FIXS>", "[", "(", "set", "RO", ":", "$", "wd", ",", "(", "Ty", "(", "vselect", "RO", ":", "$", "wd_in", ",", "RO", ":", "$", "wt", ",", "RO", ":", "$", "ws", ")", ")", ")", "]", ">", ",", "<FIXE>" ]

[ "class", "MSA_BSEL_PSEUDO_BASE", "RegisterOperand", "RO", ",", "ValueType", "Ty", ">", ":", "MSAPseudo", "(", "outs", "RO", ":", "$", "wd", ")", ",", "(", "ins", "RO", ":", "$", "wd_in", ",", "RO", ":", "$", "ws", ",", "RO", ":", "$", "wt", ")", ",", "<BUGS>", "[", "(", "set", "RO", ":", "$", "wd", ",", "(", "Ty", "(", "vselect", "RO", ":", "$", "wd_in", ",", "RO", ":", "$", "ws", ",", "RO", ":", "$", "wt", ")", ")", ")", "]", ">", ",", "<BUGE>", "PseudoInstExpansion", "(", "BSEL_V", "MSA128BOpnd", ":", "$", "wd", ",", "MSA128BOpnd", ":", "$", "wd_in", ",", "MSA128BOpnd", ":", "$", "ws", ",", "MSA128BOpnd", ":", "$", "wt", ")", ">", "{", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "if", "(", "isa", "<", "FixedVectorType", ">", "(", "DataType", ")", "&&", "!", "ST", "->", "useSVEForFixedLengthVectors", "(", ")", "&&", "DataType", "->", "getPrimitiveSizeInBits", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "bool", "isLegalMaskedLoadStore", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "ST", "->", "hasSVE", "(", ")", ")", "return", "false", ";" ]

[ "}" ]

[ "_", "_", "arm_vsubq_m_u8", "(", "uint8x16_t", "_", "_", "inactive", ",", "uint8x16_t", "_", "_", "a", ",", "uint8x16_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vsubq_m_uv16qi", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "<FIXS>", ".", "addImm", "(", "NumBytes", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "<FIXE>", "<FIXS>", ".", "addImm", "(", "NumBytes", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "<FIXE>", "<FIXS>", ".", "addReg", "(", "LdReg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "<FIXE>", "<FIXS>", "MRI", ".", "emitLoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LdReg", ",", "<NUM_LIT>", ",", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MIFlags", ")", ";", "<FIXE>" ]

[ "if", "(", "NumBytes", "<=", "<NUM_LIT>", "&&", "NumBytes", ">=", "<NUM_LIT>", ")", "AddDefaultT1CC", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVi8", ")", ",", "LdReg", ")", ")", "<BUGS>", ".", "addImm", "(", "NumBytes", ")", ";", "<BUGE>", "else", "if", "(", "NumBytes", "<NUM_LIT>", "&&", "NumBytes", ">=", "-", "<NUM_LIT>", ")", "{", "AddDefaultT1CC", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVi8", ")", ",", "LdReg", ")", ")", "<BUGS>", ".", "addImm", "(", "NumBytes", ")", ";", "<BUGE>", "AddDefaultT1CC", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tRSB", ")", ",", "LdReg", ")", ")", "<BUGS>", ".", "addReg", "(", "LdReg", ",", "RegState", "::", "Kill", ")", ";", "<BUGE>", "}", "else", "<BUGS>", "MRI", ".", "emitLoadConstPool", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LdReg", ",", "<NUM_LIT>", ",", "NumBytes", ")", ";", "<BUGE>", "int", "Opc", "=", "(", "isSub", ")", "?", "ARM", "::", "tSUBrr", ":", "(", "isHigh", "?", "ARM", "::", "tADDhirr", ":", "ARM", "::", "tADDrr", ")", ";" ]

[ "<FIXS>", "addExpr", "(", "Inst", ",", "Expr", ")", ";", "<FIXE>" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getMemBase", "(", ")", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "getMemOff", "(", ")", ";", "<BUGS>", "addExpr", "(", "Inst", ",", "Expr", ")", ";", "<BUGE>", "}", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Register", ";", "}" ]

[ "a", ";" ]

[ "return", "(", "int16x4_t", ")", "_", "_" ]

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

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

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

[ "def", "NAME", ":", "sve_int_dup_mask_imm", "<" ]

[ "}" ]

[ "gcc_assert", "(", "flag_split_stack", ")", ";", "bitmap_set_bit", "(", "regs", ",", "<NUM_LIT>", ")", ";", "}" ]

[ ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCSymbolizer", "(", "getTheGCNTarget", "(", ")", ",", "createAMDGPUSymbolizer" ]

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

[ "def", ":", "GridSize_Pat", "<", "WORKITEMABSID_U64", ",", "int_hsail_workitemabsid", ",", "i64", ",", "BrigType", "." ]

[ "}" ]

[ "vreinterpret_s8_bf16", "(", "bfloat16x4_t", "_", "_", "a", ")", "{", "return", "(", "int8x8_t", ")", "_", "_", "a", ";" ]

[ "<FIXS>", "class", "LWXC1_FT", "string", "opstr", ",", "RegisterOperand", "DRC", ",", "<FIXE>", "<FIXS>", "InstSE", "(", "outs", "DRC", ":", "$", "fd", ")", ",", "(", "ins", "PtrRC", ":", "$", "base", ",", "PtrRC", ":", "$", "index", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "set", "DRC", ":", "$", "fd", ",", "(", "OpNode", "(", "add", "iPTR", ":", "$", "base", ",", "iPTR", ":", "$", "index", ")", ")", ")", "]", ",", "Itin", ",", "FrmFI", ">", "{", "<FIXE>", "<FIXS>", "class", "SWXC1_FT", "string", "opstr", ",", "RegisterOperand", "DRC", ",", "<FIXE>", "<FIXS>", "InstSE", "(", "outs", ")", ",", "(", "ins", "DRC", ":", "$", "fs", ",", "PtrRC", ":", "$", "base", ",", "PtrRC", ":", "$", "index", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "OpNode", "DRC", ":", "$", "fs", ",", "(", "add", "iPTR", ":", "$", "base", ",", "iPTR", ":", "$", "index", ")", ")", "]", ",", "Itin", ",", "FrmFI", ">", "{", "<FIXE>" ]

[ "[", "(", "set", "RC", ":", "$", "fd", ",", "(", "fsub", "fpimm0", ",", "(", "OpNode", "(", "fmul", "RC", ":", "$", "fs", ",", "RC", ":", "$", "ft", ")", ",", "RC", ":", "$", "fr", ")", ")", ")", "]", ",", "Itin", ",", "FrmFR", ">", ";", "<BUGS>", "class", "LWXC1_FT", "string", "opstr", ",", "RegisterOperand", "DRC", ",", "RegisterOperand", "PRC", ",", "<BUGE>", "InstrItinClass", "Itin", ",", "SDPatternOperator", "OpNode", "=", "null_frag", ">", ":", "<BUGS>", "InstSE", "(", "outs", "DRC", ":", "$", "fd", ")", ",", "(", "ins", "PRC", ":", "$", "base", ",", "PRC", ":", "$", "index", ")", ",", "<BUGE>", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "<BUGS>", "[", "(", "set", "DRC", ":", "$", "fd", ",", "(", "OpNode", "(", "add", "PRC", ":", "$", "base", ",", "PRC", ":", "$", "index", ")", ")", ")", "]", ",", "Itin", ",", "FrmFI", ">", "{", "<BUGE>", "let", "AddedComplexity", "=", "<NUM_LIT>", ";", "}", "<BUGS>", "class", "SWXC1_FT", "string", "opstr", ",", "RegisterOperand", "DRC", ",", "RegisterOperand", "PRC", ",", "<BUGE>", "InstrItinClass", "Itin", ",", "SDPatternOperator", "OpNode", "=", "null_frag", ">", ":", "<BUGS>", "InstSE", "(", "outs", ")", ",", "(", "ins", "DRC", ":", "$", "fs", ",", "PRC", ":", "$", "base", ",", "PRC", ":", "$", "index", ")", ",", "<BUGE>", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "<BUGS>", "[", "(", "OpNode", "DRC", ":", "$", "fs", ",", "(", "add", "PRC", ":", "$", "base", ",", "PRC", ":", "$", "index", ")", ")", "]", ",", "Itin", ",", "FrmFI", ">", "{", "<BUGE>", "let", "AddedComplexity", "=", "<NUM_LIT>", ";", "}" ]

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

[ "class", "NLOC_H_ENC", ":", "MSA_2R_FMT", "<", "<NUM_LIT>" ]

[ "}" ]

[ "if", "(", "ExtraCode", "[", "<NUM_LIT>", "]", "!=", "<NUM_LIT>", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "w", "'", ":", "case", "'", "k", "'", ":", "case", "'", "q", "'", ":", "break", ";", "case", "'", "P", "'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "<STR_LIT>", "no-rip", "<STR_LIT>", ")", ";", "return", "false", ";" ]

[ "materializeLoadStoreOperands", "(", "Addr", ")", ";" ]

[ "case", "MVT", "::", "i1", ":", "VTIsi1", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "MVT", "::", "i8", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE8_I32_A64", ":", "WebAssembly", "::", "STORE8_I32_A32", ";", "break", ";", "case", "MVT", "::", "i16", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE16_I32_A64", ":", "WebAssembly", "::", "STORE16_I32_A32", ";", "break", ";", "case", "MVT", "::", "i32", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE_I32_A64", ":", "WebAssembly", "::", "STORE_I32_A32", ";", "break", ";", "case", "MVT", "::", "i64", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE_I64_A64", ":", "WebAssembly", "::", "STORE_I64_A32", ";", "break", ";", "case", "MVT", "::", "f32", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE_F32_A64", ":", "WebAssembly", "::", "STORE_F32_A32", ";", "break", ";", "case", "MVT", "::", "f64", ":", "Opc", "=", "A64", "?", "WebAssembly", "::", "STORE_F64_A64", ":", "WebAssembly", "::", "STORE_F64_A32", ";", "break", ";", "default", ":", "return", "false", ";", "}" ]

[ "::", "BLCFILL32rm", ":" ]

[ "case", "X86", "::", "ADC64ri32", ":", "case", "X86", "::", "ADC64ri8", ":", "case", "X86", "::", "ADC32ri", ":", "case", "X86", "::", "ADC32ri8", ":", "case", "X86", "::", "ADC16ri", ":", "case", "X86", "::", "ADC16ri8", ":", "case", "X86", "::", "ADC8ri", ":", "case", "X86", "::", "ADC64rr", ":", "case", "X86", "::", "ADC32rr", ":", "case", "X86", "::", "ADC16rr", ":", "case", "X86", "::", "ADC8rr", ":", "case", "X86", "::", "ADC64rm", ":", "case", "X86", "::", "ADC32rm", ":", "case", "X86", "::", "ADC16rm", ":", "case", "X86", "::", "ADC8rm", ":", "case", "X86", "::", "SBB64ri32", ":", "case", "X86", "::", "SBB64ri8", ":", "case", "X86", "::", "SBB32ri", ":", "case", "X86", "::", "SBB32ri8", ":", "case", "X86", "::", "SBB16ri", ":", "case", "X86", "::", "SBB16ri8", ":", "case", "X86", "::", "SBB8ri", ":", "case", "X86", "::", "SBB64rr", ":", "case", "X86", "::", "SBB32rr", ":", "case", "X86", "::", "SBB16rr", ":", "case", "X86", "::", "SBB8rr", ":", "case", "X86", "::", "SBB64rm", ":", "case", "X86", "::", "SBB32rm", ":", "case", "X86", "::", "SBB16rm", ":", "case", "X86", "::", "SBB8rm", ":", "case", "X86", "::", "NEG8r", ":", "case", "X86", "::", "NEG16r", ":", "case", "X86", "::", "NEG32r", ":", "case", "X86", "::", "NEG64r", ":", "case", "X86", "::", "SAR8r1", ":", "case", "X86", "::", "SAR16r1", ":", "case", "X86", "::", "SAR32r1", ":", "case", "X86", "::", "SAR64r1", ":", "case", "X86", "::", "SHR8r1", ":", "case", "X86", "::", "SHR16r1", ":", "case", "X86", "::", "SHR32r1", ":", "case", "X86", "::", "SHR64r1", ":", "case", "X86", "::", "SHL8r1", ":", "case", "X86", "::", "SHL16r1", ":", "case", "X86", "::", "SHL32r1", ":", "case", "X86", "::", "SHL64r1", ":", "case", "X86", "::", "LZCNT16rr", ":", "case", "X86", "::", "LZCNT16rm", ":", "case", "X86", "::", "LZCNT32rr", ":", "case", "X86", "::", "LZCNT32rm", ":", "case", "X86", "::", "LZCNT64rr", ":", "case", "X86", "::", "LZCNT64rm", ":", "case", "X86", "::", "POPCNT16rr", ":", "case", "X86", "::", "POPCNT16rm", ":", "case", "X86", "::", "POPCNT32rr", ":", "case", "X86", "::", "POPCNT32rm", ":", "case", "X86", "::", "POPCNT64rr", ":", "case", "X86", "::", "POPCNT64rm", ":", "case", "X86", "::", "TZCNT16rr", ":", "case", "X86", "::", "TZCNT16rm", ":", "case", "X86", "::", "TZCNT32rr", ":", "case", "X86", "::", "TZCNT32rm", ":", "case", "X86", "::", "TZCNT64rr", ":", "case", "X86", "::", "TZCNT64rm", ":", "return", "true", ";", "case", "X86", "::", "AND64ri32", ":", "case", "X86", "::", "AND64ri8", ":", "case", "X86", "::", "AND32ri", ":", "case", "X86", "::", "AND32ri8", ":", "case", "X86", "::", "AND16ri", ":", "case", "X86", "::", "AND16ri8", ":", "case", "X86", "::", "AND8ri", ":", "case", "X86", "::", "AND64rr", ":", "case", "X86", "::", "AND32rr", ":", "case", "X86", "::", "AND16rr", ":", "case", "X86", "::", "AND8rr", ":", "case", "X86", "::", "AND64rm", ":", "case", "X86", "::", "AND32rm", ":", "case", "X86", "::", "AND16rm", ":", "case", "X86", "::", "AND8rm", ":", "case", "X86", "::", "XOR64ri32", ":", "case", "X86", "::", "XOR64ri8", ":", "case", "X86", "::", "XOR32ri", ":", "case", "X86", "::", "XOR32ri8", ":", "case", "X86", "::", "XOR16ri", ":", "case", "X86", "::", "XOR16ri8", ":", "case", "X86", "::", "XOR8ri", ":", "case", "X86", "::", "XOR64rr", ":", "case", "X86", "::", "XOR32rr", ":", "case", "X86", "::", "XOR16rr", ":", "case", "X86", "::", "XOR8rr", ":", "case", "X86", "::", "XOR64rm", ":", "case", "X86", "::", "XOR32rm", ":", "case", "X86", "::", "XOR16rm", ":", "case", "X86", "::", "XOR8rm", ":", "case", "X86", "::", "OR64ri32", ":", "case", "X86", "::", "OR64ri8", ":", "case", "X86", "::", "OR32ri", ":", "case", "X86", "::", "OR32ri8", ":", "case", "X86", "::", "OR16ri", ":", "case", "X86", "::", "OR16ri8", ":", "case", "X86", "::", "OR8ri", ":", "case", "X86", "::", "OR64rr", ":", "case", "X86", "::", "OR32rr", ":", "case", "X86", "::", "OR16rr", ":", "case", "X86", "::", "OR8rr", ":", "case", "X86", "::", "OR64rm", ":", "case", "X86", "::", "OR32rm", ":", "case", "X86", "::", "OR16rm", ":", "case", "X86", "::", "OR8rm", ":", "case", "X86", "::", "ANDN32rr", ":", "case", "X86", "::", "ANDN32rm", ":", "case", "X86", "::", "ANDN64rr", ":", "case", "X86", "::", "ANDN64rm", ":", "case", "X86", "::", "BLSI32rr", ":", "case", "X86", "::", "BLSI32rm", ":", "case", "X86", "::", "BLSI64rr", ":", "case", "X86", "::", "BLSI64rm", ":", "case", "X86", "::", "BLSMSK32rr", ":", "case", "X86", "::", "BLSMSK32rm", ":", "case", "X86", "::", "BLSMSK64rr", ":", "case", "X86", "::", "BLSMSK64rm", ":", "case", "X86", "::", "BLSR32rr", ":", "case", "X86", "::", "BLSR32rm", ":", "case", "X86", "::", "BLSR64rr", ":", "case", "X86", "::", "BLSR64rm", ":", "case", "X86", "::", "BLCFILL32rr", ":", "case", "X86" ]

[ ")", ";" ]

[ "auto", "<STR_LIT>", "::", "<STR_LIT>", "(", "unsigned", "Width", ")", "const", "->", "IntegerType", "*", "{", "return", "IntegerType", "::", "get", "(", "F", ".", "getContext", "(", ")", ",", "Width" ]

[ "}" ]

[ "if", "(", "ElemType", "->", "getTypeID", "(", ")", "!=", "Type", "::", "IntegerTyID", ")", "return", "false", ";", "IntegerType", "*", "ElemIType", "=", "cast", "<", "IntegerType", ">", "(", "ElemType", ")", ";", "return", "ElemIType", "->", "getBitWidth", "(", ")", "==", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Dest", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", ";", "if", "(", "SDValue", "Cmp", "=", "emitConjunction", "(", "DAG", ",", "Cond", ",", "CC", ")", ")", "{", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "CCVal", "=", "DAG", ".", "getConstant", "(", "CC", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Dest", ",", "CCVal", ",", "Cmp", ")", ";", "}", "return", "SDValue", "(" ]

[ ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "I48MODE", "[", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MOV_PCREL_STEP3", ")" ]

[ ")", ";" ]

[ "const", "int64_t", "Min", "=", "std", "::", "numeric_limits", "<", "int16_t", ">", "::", "min", "(", ")", ";", "const", "int64_t", "Max", "=", "std", "::", "numeric_limits", "<", "int16_t", ">", "::", "max", "(", ")", ";", "return", "(", "(", "Cmp2", ">=", "Cmp1", "&&", "Cmp1", ">=", "Min", "&&", "Cmp2", "<=", "Max", ")", "||", "(", "Cmp1", ">=", "Cmp2", "&&", "Cmp1", "<=", "Max", "&&", "Cmp2", ">=", "Min", ")", ")", ";", "}", ";", "if", "(", "mi_match", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "m_GSMin", "(", "m_Reg", "(", "Base", ")", ",", "m_ICst", "(", "MatchInfo", ".", "Cmp1", ")", ")", ")", ")", "{", "if", "(", "mi_match", "(", "Base", ",", "MRI", ",", "m_GSMax", "(", "m_Reg", "(", "MatchInfo", ".", "Origin", ")", ",", "m_ICst", "(", "MatchInfo", ".", "Cmp2", ")", ")", ")", ")", "{", "return", "IsApplicableForCombine", "(", ")", ";", "}", "}", "if", "(", "mi_match", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "m_GSMax", "(", "m_Reg", "(", "Base", ")", ",", "m_ICst", "(", "MatchInfo", ".", "Cmp1", ")", ")", ")", ")", "{", "if", "(", "mi_match", "(", "Base", ",", "MRI", ",", "m_GSMin", "(", "m_Reg", "(", "MatchInfo", ".", "Origin", ")", ",", "m_ICst", "(", "MatchInfo", ".", "Cmp2", ")", ")", ")", ")", "{", "return", "IsApplicableForCombine", "(" ]

[ ")", "{" ]

[ "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "getSubOpcode", "(", "Is64Bit", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "break", ";", "case", "Probe", ":", "if", "(", "!", "NoStackArgProbe", ")", "{", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "RegA", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "STI", "->", "getFrameLowering", "(", ")", "->", "emitStackProbe", "(", "*", "MBB", "->", "getParent", "(", ")", ",", "*", "MBB", ",", "MI", ",", "DL", ",", "false", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64Bit", "?", "X86", "::", "SUB64rr", ":", "X86", "::", "SUB32rr", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "}", "break", ";", "}", "unsigned", "AmountReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "for", "(", ";", ";" ]

[ "x", ",", "fp_hi", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";" ]

[ "fp_hi", "=", "gen_reg_rtx", "(", "DFmode", ")", ";", "emit_insn", "(", "gen_floatsidf2", "(", "fp_hi", ",", "gen_highpart", "(", "SImode", ",", "input", ")", ")", ")", ";", "real_ldexp", "(", "&", "TWO32r", ",", "&", "dconst1", ",", "<NUM_LIT>", ")", ";", "x", "=", "const_double_from_real_value", "(", "TWO32r", ",", "DFmode", ")", ";", "fp_hi", "=", "expand_simple_binop", "(", "DFmode", ",", "MULT", ",", "fp_hi", "," ]

[ "<FIXS>", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "getAlignment", "(", ")", ",", "St", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "<FIXE>" ]

[ "SDValue", "NewExtract", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "f64", ",", "BitCast", ",", "OldExtract", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getStore", "(", "St", "->", "getChain", "(", ")", ",", "dl", ",", "NewExtract", ",", "St", "->", "getBasePtr", "(", ")", ",", "<BUGS>", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "isVolatile", "(", ")", ",", "St", "->", "isNonTemporal", "(", ")", ",", "St", "->", "getAlignment", "(", ")", ")", ";", "<BUGE>", "}", "return", "SDValue", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "'", "'", ")", "}" ]

[ "enabled_abi_idx", "[", "j", "++", "]", "=", "i", ";", "}", "}", "for", "(", "unsigned", "int", "k", "=", "<NUM_LIT>", ";", "k", "<", "j", ";", "k", "++", ")", "{", "enabled_abi_str", "[", "k", "]", "=", "abi_str", "(", "abi_priority_list", "[", "enabled_abi_idx", "[", "k", "]", "]", ")", ";", "}", "for", "(", "unsigned", "int", "k", "=", "<NUM_LIT>", ";", "k", "<", "j", "-", "<NUM_LIT>", ";", "k", "++", ")", "{", "APPEND_STRING", "(", "enabled_abi_str", "[", "k", "]", ")", "APPEND1", "(", "'", ",", "'", ")", "APPEND1", "(" ]

[ "<FIXS>", "(", "UNSPEC_CVTLQ", "\t", "<NUM_LIT>", ")", "<FIXE>" ]

[ "(", "UNSPEC_INSXH", "\t", "<NUM_LIT>", ")", "(", "UNSPEC_MSKXH", "\t", "<NUM_LIT>", ")", "(", "UNSPEC_CVTQL", "\t", "<NUM_LIT>", ")", "<BUGS>", "(", "UNSPEC_NT_LDA", "\t", "<NUM_LIT>", ")", "<BUGE>", "(", "UNSPEC_UMK_LAUM", "\t", "<NUM_LIT>", ")", "(", "UNSPEC_UMK_LALM", "\t", "<NUM_LIT>", ")", "(", "UNSPEC_UMK_LAL", "\t", "<NUM_LIT>", ")" ]

[ "}" ]

[ "assert", "(", "MCPU", "<", "array_lengthof", "(", "CPUNames", ")", "&&", "<STR_LIT>", "CPUNames[] might not be up-to-date!", "<STR_LIT>", ")", ";", "return", "CPUNames", "[", "MCPU", "]", ";" ]

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

[ "static", "MCTargetStreamer", "*", "createMCAsmTargetStreamer", "(", "MCStreamer", "&", "S", ",", "formatted_raw_ostream", "&", "OS", ",", "MCInstPrinter", "*", "InstPrint", ",", "bool", "isVerboseAsm", ")", "{", "return", "new", "SNESTargetAsmStreamer", "(" ]

[ "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "regno", "-", "FP_REG_FIRST", ")", ")", "{" ]

[ "for", "(", "unsigned", "int", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "if", "(", "offset", "<", "<NUM_LIT>", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "fp_sp_offset", ";", "for", "(", "unsigned", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "if", "(" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

[ "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";" ]

[ "case", "ISD", "::", "STACKRESTORE", ":" ]

[ "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "lowerBITCAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "lowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "lowerOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "return", "lowerATOMIC_LOAD", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "lowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKSAVE", ":", "return", "lowerSTACKSAVE", "(", "Op", ",", "DAG", ")", ";" ]

[ ";" ]

[ "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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "SI", "(", "ne", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]