Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "return", "getExprOpValue", "(", "MipsExpr", "->", "getSubExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "<FIXE>" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unhandled fixup kind!", "<STR_LIT>", ")", ";", "break", ";", "case", "MipsMCExpr", "::", "MEK_DTPREL", ":", "<BUGS>", "llvm_unreachable", "(", "<STR_LIT>", "MEK_DTPREL is used for TLS DIEExpr only", "<STR_LIT>", ")", ";", "break", ";", "<BUGE>", "case", "MipsMCExpr", "::", "MEK_CALL_HI16", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_CALL_HI16", ";", "break", ";" ]

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

[ "if", "(", "first", "<=", "<NUM_LIT>", "&&", "current_function_stdarg", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "{", "rtx", "mem", "=", "XEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "i", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "first", "+", "i", "<=", "<NUM_LIT>", ")", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "}", "if", "(", "first", ">=", "<NUM_LIT>", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "pat", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "i", ")", ")", "==", "SET", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "i", ")", ")", "=", "<NUM_LIT>", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "last", ">=", "<NUM_LIT>", ")", "{", "addr", "=", "plus_constant", "(", "base", ",", "offset", "+", "(", "<NUM_LIT>", "-", "first", ")", "*", "UNITS_PER_WORD", ")", ";", "not", "e", "=", "gen_store_multiple", "(", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "last", "-", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ")", ";", "not", "e", "=", "PATTERN", "(", "not", "e", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "not", "e", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "not", "e", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "not", "e", ",", "<NUM_LIT>", ",", "i", ")", ")", "==", "SET", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "not", "e", "," ]

[ "<FIXS>", "let", "isPseudo", "=", "true", ",", "Constraints", "=", "<STR_LIT>", "in", "<FIXE>" ]

[ "[", "]", ">", ",", "VEX_4V", ",", "T8XS", ";", "<BUGS>", "let", "Constraints", "=", "<STR_LIT>", "in", "<BUGE>", "def", "PTDPBF16PSV", ":", "PseudoI", "(", "outs", "TILE", ":", "$", "dst", ")", ",", "(", "ins", "GR16", ":", "$", "src1", ",", "GR16", ":", "$", "src2", ",", "GR16", ":", "$", "src3", ",", "TILE", ":", "$", "src4", ",", "TILE", ":", "$", "src5", ",", "TILE", ":", "$", "src6", ")", "," ]

[ "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateReg", "(", "RegNum", ",", "RegKind", "::", "Scalar", ",", "StartLoc", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ",", "EqTy", ")", ")", ";" ]

[ "unsigned", "RegNum", ";", "OperandMatchResultTy", "Res", "=", "tryParseScalarRegister", "(", "RegNum", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Res", ";", "if", "(", "!", "ParseShiftExtend", "||", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "{" ]

[ "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "WideVT", ")", ",", "BitShift", ")", ";" ]

[ "EVT", "WideVT", "=", "MVT", "::", "i32", ";", "AlignedAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "PtrVT", ",", "Addr", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "BitShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "PtrVT", ",", "Addr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "BitShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "WideVT", ",", "BitShift", ")", ";", "NegBitShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "WideVT", "," ]

[ ")", "]" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ":", "$", "addr", ",", "QQQQPR", ":", "$", "src", ")", ",", "itin", ",", "<STR_LIT>", ">", ";" ]

[ "class", "VSTQQQQPseudo", "<", "InstrItinClass", "itin", ">", ":", "PseudoNLdSt", "<", "(", "outs", ")", ",", "(", "ins", "addrmode6" ]

[ ")", ";" ]

[ "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSymbolName", "(", ")", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown instruction size!", "<STR_LIT>" ]

[ "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "make_vector", "<", "unsigned", ">", "(", "ARM", "::", "D0", ",", "ARM", "::", "D1", ",", "ARM", "::", "D2", ",", "ARM", "::", "D3", ",", "ARM", "::", "D4", ",", "ARM", "::", "D5", ",", "ARM", "::", "D6", ",", "ARM", "::", "D7", ",", "ARM", "::", "D8", ",", "ARM", "::", "D9", ",", "ARM", "::", "D10", ",", "ARM", "::", "D11", ",", "ARM", "::", "D12", ",", "ARM", "::", "D13", ",", "ARM", "::", "D14", ",", "ARM", "::", "D15", ",", "<NUM_LIT>", ")", ";" ]

[ "case", "'", "w", "'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "make_vector", "<", "unsigned", ">", "(", "ARM", "::", "S0", ",", "ARM", "::", "S1", ",", "ARM", "::", "S2", ",", "ARM", "::", "S3", ",", "ARM", "::", "S4", ",", "ARM", "::", "S5", ",", "ARM", "::", "S6", ",", "ARM", "::", "S7", ",", "ARM", "::", "S8", ",", "ARM", "::", "S9", ",", "ARM", "::", "S10", ",", "ARM", "::", "S11", ",", "ARM", "::", "S12", ",", "ARM", "::", "S13", ",", "ARM", "::", "S14", ",", "ARM", "::", "S15", ",", "ARM", "::", "S16", ",", "ARM", "::", "S17", ",", "ARM", "::", "S18", ",", "ARM", "::", "S19", ",", "ARM", "::", "S20", ",", "ARM", "::", "S21", ",", "ARM", "::", "S22", ",", "ARM", "::", "S23", ",", "ARM", "::", "S24", ",", "ARM", "::", "S25", ",", "ARM", "::", "S26", ",", "ARM", "::", "S27", ",", "ARM", "::", "S28", ",", "ARM", "::", "S29", ",", "ARM", "::", "S30", ",", "ARM", "::", "S31", ",", "<NUM_LIT>", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "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>", ";" ]

[ "<NUM_LIT>", "]", "==", "opcode", ")", "return", "Row", ";" ]

[ "for", "(", "const", "uint16_t", "(", "&", "Row", ")", "[", "<NUM_LIT>", "]", ":", "ReplaceableInstrs", ")", "if", "(", "Row", "[", "domain", "-" ]

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

[ "def", "PPCaddisDtprelHA", ":", "SDNode", "<" ]

[ "]" ]

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

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "BPF DAG->DAG Pattern Instruction Selection", "<STR_LIT>", ";", "}" ]

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

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

[ "def", "MovImm64ShifterOperand", ":", "AsmOperandClass", "{", "let", "SuperClasses", "=", "[", "ShifterOperand", "]", ";" ]

[ "container", ")", ",", "p", ")", ";" ]

[ "llvm", "::", "erase_if", "(", "std", "::", "forward", "<", "T", ">", "(" ]

[ ":" ]

[ "if", "(", "IsReversedCC", "&&", "!", "MRI", "->", "hasOneNonDBGUse", "(", "DefReg", ")", ")", "return", "false", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "Def", "->", "getIterator", "(", ")", ")", ",", "E", "=", "CmpInstr", ".", "getIterator", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "modifiesRegister", "(", "AMDGPU", "::", "SCC", ",", "&", "RI", ")", "||", "I", "->", "killsRegister", "(", "AMDGPU", "::", "SCC", ",", "&", "RI", ")", ")", "return", "false", ";", "}", "MachineOperand", "*", "SccDef", "=", "Def", "->", "findRegisterDefOperand", "(", "AMDGPU", "::", "SCC", ")", ";", "SccDef", "->", "setIsDead", "(", "false", ")", ";", "CmpInstr", ".", "eraseFromParent", "(", ")", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "DefReg", ")", ")", "{", "assert", "(", "!", "IsReversedCC", ")", ";", "return", "true", ";", "}", "MachineBasicBlock", "*", "MBB", "=", "Def", "->", "getParent", "(", ")", ";", "unsigned", "NewOpc", "=", "(", "SrcSize", "==", "<NUM_LIT>", ")", "?", "IsReversedCC", "?", "AMDGPU", "::", "S_BITCMP0_B32", ":", "AMDGPU", "::", "S_BITCMP1_B32", ":", "IsReversedCC", "?", "AMDGPU", "::", "S_BITCMP0_B64", ":", "AMDGPU", "::", "S_BITCMP1_B64", ";", "BuildMI", "(", "*", "MBB", ",", "Def", ",", "Def", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ".", "add", "(", "*", "SrcOp", ")", ".", "addImm", "(", "BitNo", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", ";", "switch", "(", "CmpInstr", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "S_CMP_EQ_U32", ":", "case", "AMDGPU", "::", "S_CMP_EQ_I32", ":", "case", "AMDGPU", "::", "S_CMPK_EQ_U32", ":", "case", "AMDGPU", "::", "S_CMPK_EQ_I32", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "false", ")", ";", "case", "AMDGPU", "::", "S_CMP_GE_U32", ":", "case", "AMDGPU", "::", "S_CMPK_GE_U32", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ")", ";", "case", "AMDGPU", "::", "S_CMP_GE_I32", ":", "case", "AMDGPU", "::", "S_CMPK_GE_I32", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "true", ")", ";", "case", "AMDGPU", "::", "S_CMP_EQ_U64", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "false", ")", ";", "case", "AMDGPU", "::", "S_CMP_LG_U32", ":", "case", "AMDGPU", "::", "S_CMP_LG_I32", ":", "case", "AMDGPU", "::", "S_CMPK_LG_U32", ":", "case", "AMDGPU", "::", "S_CMPK_LG_I32", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "false", ")", ";", "case", "AMDGPU", "::", "S_CMP_GT_U32", ":", "case", "AMDGPU", "::", "S_CMPK_GT_U32", ":", "return", "optimizeCmpAnd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ")", ";", "case", "AMDGPU", "::", "S_CMP_GT_I32", ":", "case", "AMDGPU", "::", "S_CMPK_GT_I32" ]

[ ",", "memri", ":", "$", "F", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";" ]

[ "def", "SPILL_CRBIT", ":", "PPCEmitTimePseudo", "<", "(", "outs", ")", ",", "(", "ins", "crbitrc", ":", "$", "cond" ]

[ "<STR_LIT>" ]

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

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

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

[ ")", ";" ]

[ "void", "SISubtarget", "::", "getPostRAMutations", "(", "std", "::", "vector", "<", "std", "::", "unique_ptr", "<", "ScheduleDAGMutation", ">>", "&", "Mutations", ")", "const", "{", "Mutations", ".", "push_back", "(", "llvm", "::", "make_unique", "<", "MemOpClusterMutation", ">", "(", "&", "InstrInfo", ")" ]

[ "VDIVULviml_v", "v256f64", ":", "$", "vy", ",", "(", "LO7", "$", "I", ")", ",", "v256i1", ":", "$", "vm", ",", "i32", ":", "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vdivul_vvsmvl", "v256f64", ":", "$", "vy", ",", "simm7", ":", "$", "I", ",", "v256i1", ":", "$", "vm", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", ",", "(" ]

[ "}" ]

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

[ ",", "(", "LDURDi", "am_unscaled64", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i16", "(", "load", "am_unscaled64", ":", "$", "addr", ")", ")" ]

[ "_", "MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8", "(", "*", ")", ";" ]

[ "extern", "_", "_", "inline", "char", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_reduce_mul_epi8", "(", "_", "_", "mmask32", "_", "_", "M", ",", "_", "_", "m256i", "_", "_", "W", ")", "{", "_", "_", "W", "=", "_", "mm256_mask_mov_epi8", "(", "_", "mm256_avx512_set1_epi8", "(", "<NUM_LIT>", ")", ",", "_", "_", "M", ",", "_", "_", "W", ")", ";" ]

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

[ "class", "MVE_comp", "<", "InstrItinClass", "itin", ",", "string", "iname", ",", "string", "suffix", ",", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_p", "<", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "(", "ins", "MQPR", ":", "$", "Qn", ",", "MQPR", ":", "$", "Qm", ")", ",", "itin", ",", "iname", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_r", ",", "cstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Qd", ";", "bits", "<", "<NUM_LIT>", ">", "Qn", ";", "bits", "<", "<NUM_LIT>", ">", "Qm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

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

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

[ "<FIXS>", "if", "(", "seg", "!=", "ADDR_SPACE_GENERIC", "<FIXE>" ]

[ "return", "false", ";", "<BUGS>", "if", "(", "seg", "!=", "SEG_DEFAULT", "<BUGE>", "&&", "(", "(", "base", "&&", "GET_MODE", "(", "base", ")", "!=", "word_mode", ")", "||", "(", "index", "&&", "GET_MODE", "(", "index", ")", "!=", "word_mode", ")", ")", ")", "return", "false", ";" ]

[ ".", "getNode", "(", "Val", ")", ";" ]

[ "void", "AMDGPUPALMetadata", "::", "setNumUsedVgprs", "(", "CallingConv", "::", "ID", "CC", ",", "unsigned", "Val", ")", "{", "if", "(", "isLegacy", "(", ")", ")", "{", "unsigned", "NumUsedVgprsKey", "=", "getScratchSizeKey", "(", "CC", ")", "+", "PALMD", "::", "Key", "::", "VS_NUM_USED_VGPRS", "-", "PALMD", "::", "Key", "::", "VS_SCRATCH_SIZE", ";", "setRegister", "(", "NumUsedVgprsKey", ",", "Val", ")", ";", "return", ";", "}", "getHwStage", "(", "CC", ")", "[", "<STR_LIT>", ".vgpr_count", "<STR_LIT>", "]", "=", "MsgPackDoc" ]

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

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

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

[ "return", "_", "_", "builtin_mve_vrshlq_sv8hi", "(", "_", "_" ]

[ "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "MSA128BOpnd", ":", "$", "wd", ",", "(", "vselect", "vsplati8_uimm8", ":", "$", "u8", ",", "MSA128BOpnd", ":", "$", "ws", ",", "MSA128BOpnd", ":", "$", "wd_in", ")", ")", "]", ";" ]

[ "dag", "InOperandList", "=", "(", "ins", "MSA128BOpnd", ":", "$", "wd_in", ",", "MSA128BOpnd", ":", "$", "ws", ",", "vsplat_uimm8", ":", "$", "u8", ")", ";", "string", "AsmString", "=", "<STR_LIT>", ";" ]

[ "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";" ]

[ "if", "(", "!", "opt", ")", "return", "align", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TCmode", ")", "&&", "align", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{" ]

[ ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_ADDSS", ")" ]

[ "<STR_LIT>" ]

[ "[", "(", "reg", "FLAGS_REG", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "bool", "ARMBaseInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "isKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "}" ]

[ "_", "_", "arm_vrndpq_x", "(", "float32x4_t", "_", "_", "a", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "arm_vrndpq_x_f32", "(", "_", "_", "a", ",", "_", "_", "p", ")", ";" ]

[ ";" ]

[ "while", "(", "User", "!=", "Root", ")", "{", "if", "(", "!", "User", "->", "hasOneUse", "(", ")", ")", "return", "false", ";", "User", "=", "*", "User", "->", "use_begin", "(", ")", ";", "}", "return", "true" ]

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

[ "return", "_", "_", "builtin_ia32_sqrtph128_mask", "(", "_", "_", "A", ",", "_", "mm_setzero_ph", "(", ")", ",", "(", "_", "_", "mmask8", ")" ]

[ "return", "selectLoadStore", "(", "I", ",", "MBB", ",", "MRI", ")", ";" ]

[ "if", "(", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ")", "return", "true", ";", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "selectGlobalValue", "(", "I", ",", "MBB", ",", "MRI", ")", ";", "case", "TargetOpcode", "::", "G_UBFX", ":", "case", "TargetOpcode", "::", "G_SBFX", ":", "return", "selectUbfx", "(", "I", ",", "MBB", ",", "MRI", ")", ";", "case", "TargetOpcode", "::", "G_BRCOND", ":", "return", "selectCondBr", "(", "I", ",", "MBB", ",", "MRI", ")", ";", "case", "TargetOpcode", "::", "G_SEXTLOAD", ":", "case", "TargetOpcode", "::", "G_ZEXTLOAD", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":" ]

[ "<FIXS>", "Register", "DstReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "ImmOp", ".", "ChangeToImmediate", "(", "ImmOp", ".", "getCImm", "(", ")", "->", "getZExtValue", "(", ")", ")", ";", "}", "<BUGS>", "unsigned", "DstReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "unsigned", "Size", ";", "bool", "IsSgpr", ";", "const", "RegisterBank", "*", "RB", "=", "MRI", ".", "getRegBankOrNull", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";" ]

[ "<FIXS>", "plus_constant", "(", "Pmode", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "this_fix", "->", "insn", ")", "!=", "BARRIER", ")", "{", "rtx", "addr", "<BUGS>", "plus_constant", "(", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "<BUGE>", "minipool_vector_label", ")", ",", "this_fix", "->", "minipool", "->", "offset", ")", ";", "*", "this_fix", "->", "loc", "=", "gen_rtx_MEM", "(", "this_fix", "->", "mode", ",", "addr", ")", ";" ]

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

[ "WorkQ", ".", "push_back", "(", "N", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "WorkQ", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDNode", "*", "W", "=", "WorkQ", "[", "i", "]", ";", "if", "(", "IsLoadToSelect", "(", "W", ")", ")", "{", "Loads", ".", "push_back", "(", "W", ")", ";", "continue", ";", "}", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "f", "=", "W", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "WorkQ", ".", "push_back", "(", "W", "->", "getOperand", "(", "j", ")", ".", "getNode", "(", ")", ")", ";", "}", "for", "(", "SDNode", "*", "L", ":", "Loads", ")", "ISel", ".", "Select" ]

[ "<STR_LIT>", ")" ]

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

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

[ "def", "SImm9Operand", ":", "SImmOperand", "<" ]

[ "<FIXS>", "SDValue", "Disp", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "<FIXE>", "<FIXS>", "const", "SDValue", "Ops", "[", "]", "=", "{", "VSrc", ",", "Base", ",", "getI8Imm", "(", "Scale", "->", "getSExtValue", "(", ")", ",", "DL", ")", ",", "VIdx", ",", "<FIXE>", "<FIXS>", "SDNode", "*", "ResNode", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "DL", ",", "VTs", ",", "Ops", ")", ";", "<FIXE>" ]

[ "SDVTList", "VTs", "=", "CurDAG", "->", "getVTList", "(", "VSrc", ".", "getValueType", "(", ")", ",", "VSrc", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ")", ";", "<BUGS>", "SDValue", "Disp", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "<BUGE>", "SDValue", "Segment", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "<BUGS>", "const", "SDValue", "Ops", "[", "]", "=", "{", "VSrc", ",", "Base", ",", "getI8Imm", "(", "Scale", "->", "getSExtValue", "(", ")", ")", ",", "VIdx", ",", "<BUGE>", "Disp", ",", "Segment", ",", "VMask", ",", "Chain", "}", ";", "<BUGS>", "SDNode", "*", "ResNode", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VTs", ",", "Ops", ")", ";", "<BUGE>" ]

[ "}" ]

[ "case", "ISD", "::", "Constant", ":", "return", "SelectMoveImmediate", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";" ]

[ "}" ]

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

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

[ "break", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "Val", "=", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "Val", "=", "performXORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SETCC", ":", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\nMipsSE DAG Combine:\\n", "<STR_LIT>", ";", "N", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n=> \\n", "<STR_LIT>", ";", "Val", ".", "getNode", "(", ")", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "Val", ";", "}", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(" ]

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

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

[ "<NUM_LIT>", ";" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "lwpval32", "(", "unsigned", "int", "data2", ",", "unsigned", "int", "data1", ",", "unsigned", "int", "flags", ")", "{", "_", "_", "builtin_ia32_lwpval32", "(", "data2", ",", "data1", ",", "flags", ")", ";" ]

[ ")" ]

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

[ "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";" ]

[ "const", "PseudoSourceValue", "*", "PSVa", "=", "MMOa", "->", "getPseudoValue", "(", ")", ";", "const", "PseudoSourceValue", "*", "PSVb", "=", "MMOb", "->", "getPseudoValue", "(", ")", ";", "if", "(", "PSVa", "&&", "PSVb", "&&", "(", "PSVa", "==", "PSVb", ")", ")", "SameVal", "=", "true", ";", "}", "if", "(", "SameVal", ")", "{", "int", "OffsetA", "=", "MMOa", "->", "getOffset", "(", ")", ",", "OffsetB", "=", "MMOb", "->", "getOffset", "(", ")", ";", "int", "WidthA", "=", "MMOa", "->", "getSize", "(", ")", ",", "WidthB", "=", "MMOb", "->", "getSize", "(", ")", ";", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ",", "i32imm", ")", ";" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "AddSubImmNegOperand", ";" ]

[ "output_addr_const", "(", "file", ",", "plus_constant", "(", "Pmode", ",", "x", ",", "TLS_BIAS", ")", ")", ";" ]

[ "gcc_assert", "(", "size", "==", "<NUM_LIT>", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.picptr\\ttlsmoff(", "<STR_LIT>", ",", "file", ")", ";" ]

[ "}" ]

[ "if", "(", "RM", "==", "Reloc", "::", "Default", ")", "{", "Triple", "T", "(", "TT", ")", ";", "if", "(", "T", ".", "isOSDarwin", "(", ")", ")", "RM", "=", "Reloc", "::", "DynamicNoPIC", ";", "else", "RM", "=", "Reloc", "::", "Static", ";" ]

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

[ "(", "and", "(" ]

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

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

[ "if", "(", "Pos", "!=", "ColorCombinations", ".", "end", "(", ")", ")", "{" ]

[ "SUColors", ".", "first", "=", "CurrentTopDownReservedDependencyColoring", "[", "SU", ".", "NodeNum", "]", ";", "SUColors", ".", "second", "=", "CurrentBottomUpReservedDependencyColoring", "[", "SU", ".", "NodeNum", "]", ";", "std", "::", "map", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ",", "unsigned", ">", "::", "iterator", "Pos", "=", "ColorCombinations", ".", "find", "(", "SUColors", ")", ";" ]

[ ";" ]

[ "def", "A4_paslhf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>" ]

[ "true", ";" ]

[ "auto", "Ptr", "=", "MIRBuilder", ".", "buildGlobalValue", "(", "LLT", "::", "pointer", "(", "GV", "->", "getAddressSpace", "(", ")", ",", "<NUM_LIT>", ")", ",", "GV", ")", ";", "CallInst", ".", "addReg", "(", "Ptr", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "CallInst", ".", "add", "(", "Info", ".", "Callee", ")", ";", "}", "else", "return", "false", ";", "return" ]

[ "}" ]

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "void", "XCoreInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "Register", "VReg", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "_", "_", "d", ")", ";" ]

[ "return", "_", "_", "builtin_aarch64_sqdmlsl_laneqv4hi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", "," ]

[ "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ ":" ]

[ "I", "!=", "E", ";", "++", "I", ")", "{", "MBBSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "I", ")", ";", "int", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "->", "getDesc", "(", ")", ".", "isBranch", "(", ")", ")", "{", "bool", "isCond", "=", "false", ";", "unsigned", "Bits", "=", "<NUM_LIT>", ";", "unsigned", "Scale", "=", "<NUM_LIT>", ";", "int", "UOpc", "=", "Opc", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "tBR_JTr", ":", "AFI", "->", "setAlign", "(", "<NUM_LIT>", "U", ")", ";", "if", "(", "(", "Offset", "+", "MBBSize", ")", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "MBBSize", "+=", "<NUM_LIT>", ";", "continue", ";", "default", ":", "continue", ";", "case", "ARM", "::", "Bcc", ":", "isCond", "=", "true", ";", "UOpc", "=", "ARM", "::", "B", ";", "case", "ARM", "::", "B", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "tBcc", ":", "isCond", "=", "true", ";", "UOpc", "=", "ARM", "::", "tB", ";", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "tB", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "}", "unsigned", "MaxOffs", "=", "(", "(", "<NUM_LIT>", "<<", "(", "Bits", "-", "<NUM_LIT>", ")", ")", "-", "<NUM_LIT>", ")", "*", "Scale", ";", "ImmBranches", ".", "push_back", "(", "ImmBranch", "(", "I", ",", "MaxOffs", ",", "isCond", ",", "UOpc", ")", ")", ";", "}", "if", "(", "Opc", "==", "ARM", "::", "tPUSH", "||", "Opc", "==", "ARM", "::", "tPOP_RET", ")", "PushPopMIs", ".", "push_back", "(", "I", ")", ";", "for", "(", "unsigned", "op", "=", "<NUM_LIT>", ",", "e", "=", "I", "->", "getNumOperands", "(", ")", ";", "op", "!=", "e", ";", "++", "op", ")", "if", "(", "I", "->", "getOperand", "(", "op", ")", ".", "isCPI", "(", ")", ")", "{", "unsigned", "Bits", "=", "<NUM_LIT>", ";", "unsigned", "Scale", "=", "<NUM_LIT>", ";", "unsigned", "TSFlags", "=", "I", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "switch", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "default", ":", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tLEApcrel", ")", "{", "Bits", "=", "<NUM_LIT>", ";", "break", ";", "}", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unknown addressing mode for CP reference!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Bits", "=", "<NUM_LIT>", ";", "Scale", "=", "<NUM_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>" ]

[ ";" ]

[ "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "VSX_LE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VSX_LE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_select", ":", "<", "MODE", ">" ]

[ "FAIL" ]

[ "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "if", "(", "gen_ldstwm_peep", "(", "true", ",", "<NUM_LIT>", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", ")", ")", "DONE", "else" ]

[ "return", "S", ";" ]

[ "unsigned", "size", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "regs", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ";", "align", "*=", "(", "<NUM_LIT>", "<<", "size", ")", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "Rd", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "regs", "==", "<NUM_LIT>", ")", "{", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "(", "Rd", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}", "if", "(", "Rm", "!=", "<NUM_LIT>", ")", "{", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "align", ")", ")", ";", "if", "(", "Rm", "==", "<NUM_LIT>", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "Rm", "!=", "<NUM_LIT>", ")", "{", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}" ]

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

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "R29", "]", ";", "let", "Defs", "=", "[", "PC", ",", "R31", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ ")", ";" ]

[ "setOperationPromotedToType", "(", "ISD", "::", "LOAD", ",", "VT", ",", "PromoteTo", ")", ";", "setOperationPromotedToType", "(", "ISD", "::", "STORE", ",", "VT", ",", "PromoteTo", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v2f32", "||", "VT", "==", "MVT", "::", "v4f32", "||", "VT", "==", "MVT", "::", "v2f64", ")", "{", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP2", ",", "VT", ",", "Expand", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v2f32", "||", "VT", "==", "MVT", "::", "v4f32", "||", "VT", "==", "MVT", "::", "v2f64", "||", "(", "(", "VT", "==", "MVT", "::", "v4f16", "||", "VT", "==", "MVT", "::", "v8f16", ")", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", ")", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "VT", ",", "Custom" ]

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

[ "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRA", ")", "return", "false", ";", "if", "(", "auto", "Const", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "Const", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ";" ]

[ "SDNode", "*", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallSDNode", "*", "TheCall", ",", "unsigned", "CallingConv", ",", "SelectionDAG", "&", "DAG", ")", "{", "bool", "isVarArg", "=", "TheCall", "->", "isVarArg", "(", ")", ";", "DebugLoc", "dl", "=", "TheCall", "->", "getDebugLoc", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallingConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "TheCall", ",", "RetCC_Mips", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "ResultVals", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "ResultVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "ResultVals", ".", "push_back", "(", "Chain", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "TheCall", "->", "getVTList", "(", ")", ",", "&", "ResultVals", "[", "<NUM_LIT>", "]", ",", "ResultVals", ".", "size", "(", ")", ")", ".", "getNode", "(", ")", ";", "}" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getReg", "(", ")", ")", ";" ]

[ "auto", "RC", "=", "TRI", ".", "getPhysRegClass", "(", "cast", "<", "RegisterSDNode", ">", "(", "Val", "." ]

[ "}" ]

[ "_", "_", "inline__", "static", "unsigned", "long", "long", "sh_media_MMULFX_W", "(", "unsigned", "long", "long", "mm", ",", "unsigned", "long", "long", "mn", ")", "{", "unsigned", "long", "long", "res", ";", "_", "_", "asm__", "(", "<STR_LIT>", "mmulfx.w\t%1, %2, %0", "<STR_LIT>", ":", "<STR_LIT>", "=r", "<STR_LIT>", "(", "res", ")", ":", "<STR_LIT>", "r", "<STR_LIT>", "(", "mm", ")", ",", "<STR_LIT>", "r", "<STR_LIT>", "(", "mn", ")", ")", ";", "return", "res", ";" ]

[ "MIB", ".", "setInsertPt", "(", "*", "MI", ".", "getParent", "(", ")", ",", "(", "MI", ".", "getNextNode", "(", ")", "?", "MI", ".", "getNextNode", "(", ")", "->", "getIterator", "(", ")", ":", "MI", ".", "getParent", "(", ")", "->", "end", "(", ")", ")", ")", ";" ]

[ "MachineInstr", "&", "AssignTypeInst", "=", "*", "(", "MRI", ".", "use_instr_begin", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "auto", "NewReg", "=", "createNewIdReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "Opc", ",", "MRI", ",", "*", "GR", ")", ".", "first", ";", "AssignTypeInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "NewReg", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "NewReg", ")", ";" ]

[ "cast", "<", "Instruction", ">", "(", "NAME", "#", "<STR_LIT>", ")", "V64", ":", "$", "LHS", ",", "V64", ":", "$", "MHS", ",", "V64", ":", "$", "RHS", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i16", "(", "OpNode", "(", "v4i16", "V64", ":", "$", "LHS", ")", ",", "(", "v4i16", "V64", ":", "$", "MHS", ")", ",", "(", "v4i16", "V64", ":", "$", "RHS", ")", ")", ")", ",", "(", "!" ]

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

[ "}" ]

[ "const", "HexagonFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "getFrameRegister", "(", ")", ";", "return", "getStackRegister", "(", ")", ";" ]

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

[ "return", "decodeRegisterClass", "(", "Inst", ",", "RegNo", ",", "<STR_LIT>" ]

[ "void", "altivec_expand_stvex_be", "(", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "mode", ",", "unsigned", "unspec", ")", "{", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "stvx", "=", "gen_rtx_UNSPEC", "(", "inner_mode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "tmp", ")", ",", "unspec", ")", ";", "rtx", "sel", "=", "swap_selector_for_mode", "(", "mode", ")", ";", "rtx", "vperm", ";", "gcc_assert", "(", "REG_P", "(", "op1", ")", ")", ";", "vperm", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "op1", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "vperm", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "stvx", ")", ")", ";", "}" ]

[ "Generate", "code", "for", "a", "``", "stve", "*", "x", "''", "built-in", "for", "a", "little", "endian", "target", "with", "-maltivec=be", "specified", ".", "Issue", "the", "store", "preceded", "by", "an", "element-reversing", "permute", "." ]

[ "}" ]

[ "case", "TEXTURE_SHADOW1D_ARRAY", ":", "case", "TEXTURE_SHADOW2D_ARRAY", ":", "case", "TEXTURE_SHADOWCUBE", ":", "case", "TEXTURE_SHADOWCUBE_ARRAY", ":", "useShadowVariant", "=", "true", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknow Texture Type", "<STR_LIT>", ")", ";", "}", "if", "(", "TextureType", "==", "TEXTURE_RECT", "||", "TextureType", "==", "TEXTURE_SHADOWRECT", ")", "{", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "}", "if", "(", "TextureType", "==", "TEXTURE_CUBE_ARRAY", "||", "TextureType", "==", "TEXTURE_SHADOWCUBE_ARRAY", ")", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "if", "(", "TextureType", "==", "TEXTURE_1D_ARRAY", "||", "TextureType", "==", "TEXTURE_SHADOW1D_ARRAY", ")", "{", "if", "(", "hasLOD", "&&", "useShadowVariant", ")", "{", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "}", "else", "{", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "SrcSelect", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TextureType", "==", "TEXTURE_2D_ARRAY", "||", "TextureType", "==", "TEXTURE_SHADOW2D_ARRAY", ")", "{", "CT", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "bool", "HaveMask", "=", "getTargetShuffleMask", "(", "Op", ".", "getNode", "(", ")", ",", "VT", ",", "Subtarget", "->", "getDataLayout", "(", ")", ",", "OpMask", ",", "IsUnary", ")", ";", "<FIXE>" ]

[ "return", "false", ";", "SmallVector", "int", ",", "<NUM_LIT>", ">", "OpMask", ";", "bool", "IsUnary", ";", "<BUGS>", "bool", "HaveMask", "=", "getTargetShuffleMask", "(", "Op", ".", "getNode", "(", ")", ",", "VT", ",", "OpMask", ",", "IsUnary", ")", ";", "<BUGE>", "if", "(", "!", "HaveMask", "||", "!", "IsUnary", ")", "return", "false", ";" ]

[ "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected", "<STR_LIT>", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "<NUM_LIT>", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}" ]

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

[ "bool", "nds32_expand_strlen", "(", "rtx", "result", ",", "rtx", "str", ",", "rtx", "target_char", ",", "rtx", "align", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "base_reg", ",", "backup_base_reg", ";", "rtx", "ffb_result", ";", "rtx", "target_char_ptr", ",", "length", ";", "rtx", "loop_label", ",", "tmp", ";", "if", "(", "optimize_size", "||", "optimize", "<", "<NUM_LIT>", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "str", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "target_char", ")", "||", "REG_P", "(", "target_char", ")", ")", ";", "base_reg", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "str", ",", "<NUM_LIT>", ")", ")", ";", "loop_label", "=", "gen_label_rtx", "(", ")", ";", "ffb_result", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "backup_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "backup_base_reg", ",", "base_reg", ")", ";", "emit_label", "(", "loop_label", ")", ";", "emit_insn", "(", "gen_unaligned_load_update_base_w", "(", "base_reg", ",", "tmp", ",", "base_reg", ")", ")", ";", "emit_insn", "(", "gen_unspec_ffb", "(", "ffb_result", ",", "tmp", ",", "target_char", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "ffb_result", ",", "const0_rtx", ",", "EQ", ",", "NULL", ",", "SImode", ",", "<NUM_LIT>", ",", "loop_label", ")", ";", "target_char_ptr", "=", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "base_reg", ",", "ffb_result", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_WIDEN", ")", ";", "length", "=", "expand_binop", "(", "Pmode", ",", "sub_optab", ",", "target_char_ptr", ",", "backup_base_reg", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "result", ",", "length", ")", ";", "return", "true", ";", "}" ]

[ "Auxiliary", "function", "for", "expand", "strlen", "pattern", "." ]

[ "let", "D", "=", "VFPNeonA8Domain", ";" ]

[ "def", "VUITOS", ":", "AVConv1InSs_Encode", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "SPR", ":", "$", "Sd", ")", ",", "(", "ins", "SPR", ":", "$", "Sm", ")", ",", "IIC_fpCVTIS", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteFPCVT", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "return", "ARMBaseInstrInfo", "::", "copyRegToReg", "(", "MBB", ",", "I", ",", "DestReg", ",", "SrcReg", ",", "DestRC", ",", "SrcRC", ",", "DL", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "return", "ARMBaseInstrInfo", "::", "copyRegToReg", "(", "MBB", ",", "I", ",", "DestReg", ",", "SrcReg", ",", "DestRC", ",", "SrcRC", ")", ";", "<BUGE>", "}", "void", "Thumb2InstrInfo", "::" ]

[ "SDValue", "AMDGPUTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "Function", "&", "Fn", "=", "*", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "StringRef", "FuncName", "(", "<STR_LIT>", "<unknown>", "<STR_LIT>", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getSymbol", "(", ")", ";", "else", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "DiagnosticInfoUnsupported", "NoCalls", "(", "Fn", ",", "<STR_LIT>", "unsupported call to function ", "<STR_LIT>", "+", "FuncName", ",", "CLI", ".", "DL", ".", "getDebugLoc", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoCalls", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CLI", ".", "Ins", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "InVals", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "CLI", ".", "Ins", "[", "I", "]", ".", "VT", ")", ")", ";", "return", "DAG", ".", "getEntryNode", "(", ")", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

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

[ "if", "(", "MO", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_Immediate", ")", "O", "<<", "(", "unsigned", "int", ")", "MO", "." ]

[ "<FIXS>", "FunctionPass", "*", "createWebAssemblyMemIntrinsicResults", "(", ")", ";", "<FIXE>" ]

[ "FunctionPass", "*", "createWebAssemblyReplacePhysRegs", "(", ")", ";", "FunctionPass", "*", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ";", "FunctionPass", "*", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ";", "<BUGS>", "FunctionPass", "*", "createWebAssemblyStoreResults", "(", ")", ";", "<BUGE>", "FunctionPass", "*", "createWebAssemblyRegStackify", "(", ")", ";", "FunctionPass", "*", "createWebAssemblyRegColoring", "(", ")", ";", "FunctionPass", "*", "createWebAssemblyExplicitLocals", "(", ")", ";" ]

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

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

[ "unknown branch fusion type", "<STR_LIT>", ")", ";" ]

[ "if", "(", "BranchKind", "==", "JumpKind", "::", "Invalid", ")", "return", "false", ";", "if", "(", "FirstMI", "==", "nullptr", ")", "return", "true", ";", "const", "FirstInstrKind", "TestKind", "=", "classifyFirst", "(", "*", "FirstMI", ")", ";", "if", "(", "ST", ".", "hasBranchFusion", "(", ")", ")", "{", "return", "(", "TestKind", "==", "FirstInstrKind", "::", "Cmp", "||", "TestKind", "==", "FirstInstrKind", "::", "Test", ")", ";", "}", "if", "(", "ST", ".", "hasMacroFusion", "(", ")", ")", "{", "switch", "(", "TestKind", ")", "{", "case", "FirstInstrKind", "::", "Test", ":", "case", "FirstInstrKind", "::", "And", ":", "return", "true", ";", "case", "FirstInstrKind", "::", "Cmp", ":", "case", "FirstInstrKind", "::", "ALU", ":", "return", "BranchKind", "==", "JumpKind", "::", "ELG", "||", "BranchKind", "==", "JumpKind", "::", "AB", ";", "case", "FirstInstrKind", "::", "IncDec", ":", "return", "BranchKind", "==", "JumpKind", "::", "ELG", ";", "case", "FirstInstrKind", "::", "Invalid", ":", "return", "false", ";", "}", "}", "llvm_unreachable", "(", "<STR_LIT>" ]

[ "}" ]

[ "class", "StoreLeftRight", "<", "string", "opstr", ",", "SDNode", "OpNode", ",", "RegisterOperand", "RO", ",", "InstrItinClass", "Itin", ">", ":", "InstSE", "<", "(", "outs", ")", ",", "(", "ins", "RO", ":", "$", "rt", ",", "mem", ":", "$", "addr", ")", ",", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "[", "(", "OpNode", "RO", ":", "$", "rt", ",", "addr", ":", "$", "addr", ")", "]", ",", "Itin", ",", "FrmI", ">", "{", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "(", "<NUM_LIT>", ",", "DL", ",", "CarryVT", ")", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "DAG", ".", "getVTList", "(", "CarryVT", ",", "MVT", "::", "i32", ")", ",", "BoolCarry", ",", "DAG", ".", "getConstant" ]

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

[ "return", "(", "uint16x4_t", ")", "_", "_", "builtin_neon_vcgev4hi", "(", "_", "_", "a", ",", "_" ]

[ "A64FXIPEAGA", ",", "A64FXIPEAGB", "]", ">", ";" ]

[ "def", "A64FXGI056", ":", "ProcResGroup", "<", "[", "A64FXIPFLA", "," ]

[ "void", "xtensa_expand_atomic", "(", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ",", "bool", "after", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "struct", "alignment_context", "ac", ";", "rtx_code_label", "*", "csloop", "=", "gen_label_rtx", "(", ")", ";", "rtx", "cmp", ",", "tmp", ";", "rtx", "old", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "new", "_", "rtx", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "or", "ig", "=", "NULL_RTX", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ")", ";", "if", "(", "ac", ".", "shift", "!=", "NULL_RTX", ")", "val", "=", "xtensa_expand_mask_and_shift", "(", "val", ",", "mode", ",", "ac", ".", "shift", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "or", "ig", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "convert_move", "(", "or", "ig", ",", "val", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "SET", ":", "case", "IOR", ":", "case", "XOR", ":", "break", ";", "case", "MULT", ":", "case", "AND", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "val", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "cmp", "=", "force_reg", "(", "SImode", ",", "ac", ".", "memsi", ")", ";", "emit_label", "(", "csloop", ")", ";", "emit_move_insn", "(", "old", ",", "cmp", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "old", ",", "or", "ig", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "case", "SET", ":", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "old", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "tmp", ",", "val", ",", "new", "_", "rtx", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "old", ",", "val", ",", "new", "_", "rtx", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "old", ",", "val", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "tmp", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "tmp", ",", "ac", ".", "modemask", ",", "new", "_", "rtx", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "tmp", "!=", "new", "_", "rtx", ")", "emit_move_insn", "(", "new", "_", "rtx", ",", "tmp", ")", ";", "emit_insn", "(", "gen_sync_compare_and_swapsi", "(", "cmp", ",", "ac", ".", "memsi", ",", "old", ",", "new", "_", "rtx", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "cmp", ",", "old", ",", "NE", ",", "const0_rtx", ",", "SImode", ",", "true", ",", "csloop", ")", ";", "if", "(", "target", ")", "{", "tmp", "=", "(", "after", "?", "new", "_", "rtx", ":", "cmp", ")", ";", "convert_move", "(", "target", ",", "(", "ac", ".", "shift", "==", "NULL_RTX", "?", "tmp", ":", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "tmp", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ")", ",", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "Expand", "an", "atomic", "operation", "CODE", "of", "mode", "MODE", "(", "either", "HImode", "or", "QImode", "--", "the", "default", "expansion", "works", "fine", "for", "SImode", ")", ".", "MEM", "is", "the", "memory", "location", "and", "VAL", "the", "value", "to", "play", "with", ".", "If", "AFTER", "is", "true", "then", "store", "the", "value", "MEM", "holds", "after", "the", "operation", ",", "if", "AFTER", "is", "false", "then", "store", "the", "value", "MEM", "holds", "before", "the", "operation", ".", "If", "TARGET", "is", "zero", "then", "discard", "that", "value", ",", "else", "store", "it", "to", "TARGET", "." ]