Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "VT", ")", ";" ]

[ "return", "VT", ".", "isScalableVector", "(", ")", "&&", "isTypeLegal", "(" ]

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

[ "<STR_LIT>", ";" ]

[ "class", "VLD2", "<", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "RegisterOperand", "VdTy", ",", "InstrItinClass", "itin", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", "VdTy", ":", "$", "Vd", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ")", ",", "itin", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=" ]

[ "AMDGPUSubtarget", "&", "AMDGPUSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "<NUM_LIT>", ">", "FullFS", "(", "<STR_LIT>", "+promote-alloca,+fp64-denormals,", "<STR_LIT>", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "<STR_LIT>", "+flat-for-global,", "<STR_LIT>", ";", "FullFS", "+=", "FS", ";", "if", "(", "GPU", "==", "<STR_LIT>", "<STR_LIT>", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "GPU", "=", "<STR_LIT>", "SI", "<STR_LIT>", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "if", "(", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "FP32Denormals", "=", "false", ";", "FP64Denormals", "=", "false", ";", "}", "return", "*", "this", ";", "}" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

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

[ "(", "fix", ":", "SI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")" ]

[ "<FIXS>", ":", "XI", "oops", ",", "iops", ",", "AddrModeNone", ",", "SizeSpecial", ",", "IndexModeNone", ",", "BranchMisc", ",", "<FIXE>" ]

[ "class", "JTI", "bits", "<NUM_LIT>", ">", "opcod", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", "<BUGS>", ":", "XI", "opcod", ",", "oops", ",", "iops", ",", "AddrModeNone", ",", "SizeSpecial", ",", "IndexModeNone", ",", "BranchMisc", ",", "<BUGE>", "asm", ",", "<STR_LIT>", ",", "pattern", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcod", ";" ]

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

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

[ "BuildMI", "(", "*", "BB", ",", "&", "I", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "CondPhysReg", ")", ".", "addReg", "(", "CondReg", ")", ";" ]

[ "if", "(", "!", "isVCC", "(", "CondReg", ",", "*", "MRI", ")", ")", "{", "if", "(", "MRI", "->", "getType", "(", "CondReg", ")", "!=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", "return", "false", ";", "CondPhysReg", "=", "AMDGPU", "::", "SCC", ";", "BrOpcode", "=", "AMDGPU", "::", "S_CBRANCH_SCC1", ";", "ConstrainRC", "=", "&", "AMDGPU", "::", "SReg_32RegClass", ";", "}", "else", "{", "CondPhysReg", "=", "TRI", ".", "getVCC", "(", ")", ";", "BrOpcode", "=", "AMDGPU", "::", "S_CBRANCH_VCCNZ", ";", "ConstrainRC", "=", "TRI", ".", "getBoolRC", "(", ")", ";", "}", "if", "(", "!", "MRI", "->", "getRegClassOrNull", "(", "CondReg", ")", ")", "MRI", "->", "setRegClass", "(", "CondReg", ",", "ConstrainRC", ")", ";" ]

[ ";" ]

[ "if", "(", "!", "RX_REG_P", "(", "base", ")", "||", "!", "CONST_INT_P", "(", "index", ")", ")", "return", "false", ";", "return", "IN_RANGE", "(", "INTVAL", "(", "index", ")", ",", "<NUM_LIT>", ",", "(", "<NUM_LIT>", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", "-", "<NUM_LIT>", ")", ";", "}", "case", "SYMBOL_REF", ":", "return", "true" ]

[ "i", "=", "PREV_INSN", "(", "i", ")", ";" ]

[ "if", "(", "i", "==", "NULL", "||", "i", "==", "PREV_INSN", "(", "BB_HEAD", "(", "bb", ")", ")", ")", "continue", ";", "if", "(", "any_condjump_p", "(", "i", ")", "&&", "onlyjump_p", "(", "i", ")", ")", "{", "try_optimize_cbranch", "(", "i", ")", ";" ]

[ ")", "_", "_", "Z", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vpmadd52huq256", "(", "(", "_", "_", "v4di", ")", "_", "_", "X", ",", "(", "_", "_", "v4di", ")", "_", "_", "Y", ",", "(", "_", "_", "v4di" ]

[ "_", "mm_mask_cmpge_epu32_mask", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{" ]

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

[ ",", "(", "INST8B", "VPR64", ":", "$", "src", ",", "VPR64", ":", "$", "Rn", ",", "VPR64", ":", "$", "Rm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v8i8", "(", "int_arm_neon_vbsl", "(", "v8i8", "VPR64", ":", "$", "src", ")", ",", "(", "v8i8", "VPR64", ":", "$", "Rn", ")", ",", "(", "v8i8", "VPR64", ":", "$", "Rm", ")", ")", ")" ]

[ "else", "*", "update", "=", "build2", "(", "MODIFY_EXPR", ",", "integer_type_node", ",", "exceptions_var", ",", "exceptions_sse", ")", ";" ]

[ "hold_mod_val", "=", "build2", "(", "BIT_AND_EXPR", ",", "unsigned_type_node", ",", "hold_mod_val", ",", "build_int_cst", "(", "unsigned_type_node", ",", "<NUM_LIT>", ")", ")", ";", "tree", "hold_assign_mod", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "mxcsr_mod_var", ",", "hold_mod_val", ")", ";", "tree", "ldmxcsr_hold_call", "=", "build_call_expr", "(", "ldmxcsr", ",", "<NUM_LIT>", ",", "mxcsr_mod_var", ")", ";", "tree", "hold_all", "=", "build2", "(", "COMPOUND_EXPR", ",", "unsigned_type_node", ",", "hold_assign_orig", ",", "hold_assign_mod", ")", ";", "hold_all", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "hold_all", ",", "ldmxcsr_hold_call", ")", ";", "if", "(", "*", "hold", ")", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "hold", ",", "hold_all", ")", ";", "else", "*", "hold", "=", "hold_all", ";", "tree", "ldmxcsr_clear_call", "=", "build_call_expr", "(", "ldmxcsr", ",", "<NUM_LIT>", ",", "mxcsr_mod_var", ")", ";", "if", "(", "*", "clear", ")", "*", "clear", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "clear", ",", "ldmxcsr_clear_call", ")", ";", "else", "*", "clear", "=", "ldmxcsr_clear_call", ";", "tree", "stxmcsr_update_call", "=", "build_call_expr", "(", "stmxcsr", ",", "<NUM_LIT>", ")", ";", "tree", "exceptions_sse", "=", "fold_convert", "(", "integer_type_node", ",", "stxmcsr_update_call", ")", ";", "if", "(", "*", "update", ")", "{", "tree", "exceptions_mod", "=", "build2", "(", "BIT_IOR_EXPR", ",", "integer_type_node", ",", "exceptions_var", ",", "exceptions_sse", ")", ";", "tree", "exceptions_assign", "=", "build2", "(", "MODIFY_EXPR", ",", "integer_type_node", ",", "exceptions_var", ",", "exceptions_mod", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "integer_type_node", ",", "*", "update", ",", "exceptions_assign", ")", ";", "}" ]

[ "}" ]

[ "rtx", "tmp", "=", "gen_reg_rtx", "(", "shift_mode", ")", ";", "idx", "=", "convert_modes", "(", "shift_mode", ",", "idx_mode", ",", "idx", ",", "<NUM_LIT>", ")", ";", "emit_insn", "(", "gen_ashl", "(", "tmp", ",", "idx", ",", "GEN_INT", "(", "shift", ")", ")", ")", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_add", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_sub", "(", "tmp", ",", "GEN_INT", "(", "<NUM_LIT>", "-", "width", ")", ",", "tmp", ")", ")", ";", "rtx", "mask", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "rtx", "mask_v2di", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "RTVEC_ELT", "(", "v", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "RTVEC_ELT", "(", "v", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "mode_mask", ")", ";", "}", "else", "{", "RTVEC_ELT", "(", "v", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "mode_mask", ")", ";", "RTVEC_ELT", "(", "v", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "}", "emit_insn", "(", "gen_vec_initv2didi", "(", "mask_v2di", ",", "gen_rtx_PARALLEL", "(", "V2DImode", ",", "v", ")", ")", ")", ";", "rtx", "sub_mask", "=", "simplify_gen_subreg", "(", "V16QImode", ",", "mask_v2di", ",", "V2DImode", ",", "<NUM_LIT>", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "sub_mask", ")", ")", ";", "rtx", "tmp_val", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "inner_mode", "==", "E_SFmode", ")", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "emit_insn", "(", "gen_movsi_from_sf", "(", "tmp_val", ",", "val", ")", ")", ";", "else", "{", "rtx", "stack", "=", "rs6000_allocate_stack_temp", "(", "SFmode", ",", "false", ",", "true", ")", ";", "emit_insn", "(", "gen_movsf_hardfloat", "(", "stack", ",", "val", ")", ")", ";", "rtx", "stack2", "=", "copy_rtx", "(", "stack", ")", ";", "PUT_MODE", "(", "stack2", ",", "SImode", ")", ";", "emit_move_insn", "(", "tmp_val", ",", "stack2", ")", ";", "}", "else", "tmp_val", "=", "force_reg", "(", "SImode", ",", "val", ")", ";", "rtx", "val_v16qi", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "rtx", "val_v2di", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "rtvec", "vec_val", "=", "rtvec_alloc", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "RTVEC_ELT", "(", "vec_val", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "RTVEC_ELT", "(", "vec_val", ",", "<NUM_LIT>", ")", "=", "tmp_val", ";", "}", "else", "{", "RTVEC_ELT", "(", "vec_val", ",", "<NUM_LIT>", ")", "=", "tmp_val", ";", "RTVEC_ELT", "(", "vec_val", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "<NUM_LIT>", ")", ";" ]

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

[ "(", "define_cpu_unit" ]

[ "PROP_rtl_split_insns", ")", "&&", "!", "reload_completed", ";" ]

[ "static", "bool", "nios2_large_constant_allowed", "(", "void", ")", "{", "return", "!", "(", "cfun", "->", "curr_properties", "&" ]

[ ")", "]" ]

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

[ "Writer", "->", "addRelocation", "(", "nullptr", ",", "Fragment", "->", "getParent", "(", ")", ",", "MRE", ")", ";" ]

[ "uint32_t", "Value", "=", "Writer", "->", "getSymbolAddress", "(", "*", "A", ",", "Layout", ")", ";", "uint64_t", "SecAddr", "=", "Writer", "->", "getSectionAddress", "(", "A", "->", "getFragment", "(", ")", "->", "getParent", "(", ")", ")", ";", "FixedValue", "+=", "SecAddr", ";", "uint32_t", "Value2", "=", "<NUM_LIT>", ";", "if", "(", "const", "MCSymbolRefExpr", "*", "B", "=", "Target", ".", "getSymB", "(", ")", ")", "{", "assert", "(", "Type", "==", "MachO", "::", "ARM_RELOC_VANILLA", "&&", "<STR_LIT>", "invalid reloc for 2 symbols", "<STR_LIT>", ")", ";", "const", "MCSymbol", "*", "SB", "=", "&", "B", "->", "getSymbol", "(", ")", ";", "if", "(", "!", "SB", "->", "getFragment", "(", ")", ")", "{", "Asm", ".", "getContext", "(", ")", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "symbol '", "<STR_LIT>", "+", "B", "->", "getSymbol", "(", ")", ".", "getName", "(", ")", "+", "<STR_LIT>", "' can not be undefined in a subtraction expression", "<STR_LIT>", ")", ";", "return", ";", "}", "Type", "=", "MachO", "::", "ARM_RELOC_SECTDIFF", ";", "Value2", "=", "Writer", "->", "getSymbolAddress", "(", "B", "->", "getSymbol", "(", ")", ",", "Layout", ")", ";", "FixedValue", "-=", "Writer", "->", "getSectionAddress", "(", "SB", "->", "getFragment", "(", ")", "->", "getParent", "(", ")", ")", ";", "}", "if", "(", "Type", "==", "MachO", "::", "ARM_RELOC_SECTDIFF", "||", "Type", "==", "MachO", "::", "ARM_RELOC_LOCAL_SECTDIFF", ")", "{", "MachO", "::", "any_relocation_info", "MRE", ";", "MRE", ".", "r_word0", "=", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "(", "MachO", "::", "ARM_RELOC_PAIR", "<<", "<NUM_LIT>", ")", "|", "(", "Log2Size", "<<", "<NUM_LIT>", ")", "|", "(", "IsPCRel", "<<", "<NUM_LIT>", ")", "|", "MachO", "::", "R_SCATTERED", ")", ";", "MRE", ".", "r_word1", "=", "Value2", ";", "Writer", "->", "addRelocation", "(", "nullptr", ",", "Fragment", "->", "getParent", "(", ")", ",", "MRE", ")", ";", "}", "MachO", "::", "any_relocation_info", "MRE", ";", "MRE", ".", "r_word0", "=", "(", "(", "FixupOffset", "<<", "<NUM_LIT>", ")", "|", "(", "Type", "<<", "<NUM_LIT>", ")", "|", "(", "Log2Size", "<<", "<NUM_LIT>", ")", "|", "(", "IsPCRel", "<<", "<NUM_LIT>", ")", "|", "MachO", "::", "R_SCATTERED", ")", ";", "MRE", ".", "r_word1", "=", "Value", ";" ]

[ "<FIXS>", "with", "operands", "OPERANDS", ".", "This", "is", "very", "similar", "to", "the", "preceding", "<FIXE>" ]

[ "}", "char", "*" ]

[ ")", ")" ]

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

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", "{", "return", "new", "WebAssemblyFixIrreducibleControlFlow", "(", ")", ";" ]

[ "while", "(", "++", "Start", "<=", "End", ")", "VSCCLRM", ".", "addReg", "(", "ARM", "::", "S0", "+", "Start", ",", "RegState", "::", "Define", ")", ";" ]

[ "int", "Start", "=", "-", "<NUM_LIT>", ",", "End", "=", "-", "<NUM_LIT>", ";", "for", "(", "int", "S", "=", "<NUM_LIT>", ",", "E", "=", "ClearRegs", ".", "size", "(", ")", ";", "S", "!=", "E", ";", "++", "S", ")", "{", "if", "(", "ClearRegs", "[", "S", "]", "&&", "S", "==", "End", "+", "<NUM_LIT>", ")", "{", "End", "=", "S", ";", "continue", ";", "}", "if", "(", "Start", "<", "End", ")", "{", "MachineInstrBuilder", "VSCCLRM", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "RetI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "VSCCLRMS", ")", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "while", "(", "++", "Start", "<=", "End", ")", "VSCCLRM", ".", "addReg", "(", "ARM", "::", "S0", "+", "Start", ",", "RegState", "::", "Define", ")", ";", "VSCCLRM", ".", "addReg", "(", "ARM", "::", "VPR", ",", "RegState", "::", "Define", ")", ";", "}", "Start", "=", "End", "=", "S", ";", "}", "if", "(", "Start", "<", "End", ")", "{", "MachineInstrBuilder", "VSCCLRM", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "RetI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "VSCCLRMS", ")", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";" ]

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

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

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

[ "let", "ParserMatchClass", "=", "SVELogicalImmNotOperand", "<" ]

[ "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "SL", ",", "MVT", "::", "f64", ",", "And", ",", "One", ",", "Zero", ")", ";" ]

[ "SDValue", "Trunc", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FTRUNC", ",", "SL", ",", "MVT", "::", "f64", ",", "Src", ")", ";", "const", "SDValue", "Zero", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "f64", ")", ";", "const", "SDValue", "One", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "f64", ")", ";", "EVT", "SetCCVT", "=", "getSetCCResultType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "f64", ")", ";", "SDValue", "Lt0", "=", "DAG", ".", "getSetCC", "(", "SL", ",", "SetCCVT", ",", "Src", ",", "Zero", ",", "ISD", "::", "SETOGT", ")", ";", "SDValue", "NeTrunc", "=", "DAG", ".", "getSetCC", "(", "SL", ",", "SetCCVT", ",", "Src", ",", "Trunc", ",", "ISD", "::", "SETONE", ")", ";", "SDValue", "And", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "SL", ",", "SetCCVT", ",", "Lt0", ",", "NeTrunc", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";" ]

[ ".", "addReg", "(", "NewExec", ")", ";" ]

[ "for", "(", "unsigned", "PieceIdx", "=", "<NUM_LIT>", ";", "PieceIdx", "!=", "NumPieces", ";", "++", "PieceIdx", ")", "{", "Register", "UnmergePiece", "=", "Unmerge", ".", "getReg", "(", "PieceIdx", ")", ";", "Register", "CurrentLaneOpReg", ";", "if", "(", "Is64", ")", "{", "Register", "CurrentLaneOpRegLo", "=", "MRI", ".", "createGenericVirtualRegister", "(", "S32", ")", ";", "Register", "CurrentLaneOpRegHi", "=", "MRI", ".", "createGenericVirtualRegister", "(", "S32", ")", ";", "MRI", ".", "setRegClass", "(", "UnmergePiece", ",", "&", "AMDGPU", "::", "VReg_64RegClass", ")", ";", "MRI", ".", "setRegClass", "(", "CurrentLaneOpRegLo", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "MRI", ".", "setRegClass", "(", "CurrentLaneOpRegHi", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "BuildMI", "(", "*", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "CurrentLaneOpRegLo", ")", ".", "addReg", "(", "UnmergePiece", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub0", ")", ";", "BuildMI", "(", "*", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "CurrentLaneOpRegHi", ")", ".", "addReg", "(", "UnmergePiece", ",", "<NUM_LIT>", ",", "AMDGPU", "::", "sub1", ")", ";", "CurrentLaneOpReg", "=", "B", ".", "buildMerge", "(", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ",", "{", "CurrentLaneOpRegLo", ",", "CurrentLaneOpRegHi", "}", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "MRI", ".", "setRegClass", "(", "CurrentLaneOpReg", ",", "&", "AMDGPU", "::", "SReg_64_XEXECRegClass", ")", ";", "if", "(", "OpTy", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "ReadlanePieces", ".", "push_back", "(", "CurrentLaneOpReg", ")", ";", "}", "else", "{", "ReadlanePieces", ".", "push_back", "(", "CurrentLaneOpRegLo", ")", ";", "ReadlanePieces", ".", "push_back", "(", "CurrentLaneOpRegHi", ")", ";", "}", "}", "else", "{", "CurrentLaneOpReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "S32", ")", ";", "MRI", ".", "setRegClass", "(", "UnmergePiece", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MRI", ".", "setRegClass", "(", "CurrentLaneOpReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "BuildMI", "(", "*", "LoopBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "CurrentLaneOpReg", ")", ".", "addReg", "(", "UnmergePiece", ")", ";", "ReadlanePieces", ".", "push_back", "(", "CurrentLaneOpReg", ")", ";", "}", "Register", "NewCondReg", "=", "MRI", ".", "createVirtualRegister", "(", "WaveRC", ")", ";", "bool", "First", "=", "CondReg", "==", "AMDGPU", "::", "NoRegister", ";", "if", "(", "First", ")", "CondReg", "=", "NewCondReg", ";", "B", ".", "buildInstr", "(", "CmpOp", ")", ".", "addDef", "(", "NewCondReg", ")", ".", "addReg", "(", "CurrentLaneOpReg", ")", ".", "addReg", "(", "UnmergePiece", ")", ";", "if", "(", "!", "First", ")", "{", "Register", "AndReg", "=", "MRI", ".", "createVirtualRegister", "(", "WaveRC", ")", ";", "B", ".", "buildInstr", "(", "WaveAndOpc", ")", ".", "addDef", "(", "AndReg", ")", ".", "addReg", "(", "NewCondReg", ")", ".", "addReg", "(", "CondReg", ")", ";", "CondReg", "=", "AndReg", ";", "}", "}", "if", "(", "OpTy", ".", "isVector", "(", ")", ")", "{", "auto", "Merge", "=", "B", ".", "buildBuildVector", "(", "OpTy", ",", "ReadlanePieces", ")", ";", "Op", ".", "setReg", "(", "Merge", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "auto", "Merge", "=", "B", ".", "buildMerge", "(", "OpTy", ",", "ReadlanePieces", ")", ";", "Op", ".", "setReg", "(", "Merge", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "}", "MRI", ".", "setRegBank", "(", "Op", ".", "getReg", "(", ")", ",", "AMDGPU", "::", "SGPRRegBank", ")", ";", "}", "}", "}", "}", "B", ".", "setInsertPt", "(", "*", "LoopBB", ",", "LoopBB", "->", "end", "(", ")", ")", ";", "B", ".", "buildInstr", "(", "AndSaveExecOpc", ")", ".", "addDef", "(", "NewExec", ")", ".", "addReg", "(", "CondReg", ",", "RegState", "::", "Kill", ")", ";", "MRI", ".", "setSimpleHint", "(", "NewExec", ",", "CondReg", ")", ";", "B", ".", "buildInstr", "(", "XorTermOpc", ")", ".", "addDef", "(", "ExecReg", ")", ".", "addReg", "(", "ExecReg", ")" ]

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

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

[ "MIB", ")", ";" ]

[ "assert", "(", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_FCONSTANT", "&&", "OpIdx", "==", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected G_FCONSTANT", "<STR_LIT>", ")", ";", "const", "ConstantFP", "*", "FPImm", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getFPImm", "(", ")", ";", "addNumImm", "(", "FPImm", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", "," ]

[ ",", "_", "_", "p", ")", ";" ]

[ "return", "_", "_", "arm_vrev64q_m_f32", "(", "_", "_", "inactive", ",", "_", "_", "a" ]

[ "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "*", "T", ",", "createAArch64MCInstPrinter", ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCInstrAnalysis", "(", "*", "T", ",", "createAArch64InstrAnalysis", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "*", "T", ",", "createAArch64MCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterELFStreamer", "(", "*", "T", ",", "createELFStreamer", ")", ";", "TargetRegistry", "::", "RegisterMachOStreamer", "(", "*", "T", ",", "createMachOStreamer", ")", ";", "TargetRegistry", "::", "RegisterObjectTargetStreamer", "(", "*", "T", ",", "createAArch64ObjectTargetStreamer", ")", ";", "TargetRegistry", "::", "RegisterAsmTargetStreamer", "(", "*", "T", ",", "createAArch64AsmTargetStreamer", ")", ";" ]

[ ")", "{" ]

[ "else", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "%<bank_switch%> has no effect on non-interrupt functions", "<STR_LIT>", ")", ";", "reg_save_size", "=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "emit_insn", "(", "gen_fset_b", "(", ")", ")", ";", "else", "if", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", "emit_insn", "(", "gen_pushm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "}", "frame_size", "=", "m32c_initial_elimination_offset", "(", "FB_REGNO", ",", "SP_REGNO", ")", "-", "reg_save_size", ";", "if", "(", "frame_size", "==", "<NUM_LIT>", "&&", "!", "m32c_function_needs_enter", "(", ")", ")", "cfun", "->", "machine", "->", "use_rts", "=", "<NUM_LIT>", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "frame_size", ";", "if", "(", "frame_size", ">", "<NUM_LIT>", ")", "{", "extra_frame_size", "=", "frame_size", "-", "<NUM_LIT>", ";", "frame_size", "=", "<NUM_LIT>", ";", "}", "if", "(", "cfun", "->", "machine", "->", "use_rts", "==", "<NUM_LIT>", ")", "F", "(", "emit_insn", "(", "m32c_all_frame_related", "(", "TARGET_A16", "?", "gen_prologue_enter_16", "(", "GEN_INT", "(", "frame_size", "+", "<NUM_LIT>", ")", ")", ":", "gen_prologue_enter_24", "(", "GEN_INT", "(", "frame_size", "+", "<NUM_LIT>", ")", ")", ")", ")", ")", ";", "if", "(", "extra_frame_size" ]

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

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

[ "}" ]

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

[ "}" ]

[ "MCELFStreamer", "*", "createMipsELFStreamer", "(", "MCContext", "&", "Context", ",", "MCAsmBackend", "&", "MAB", ",", "raw_ostream", "&", "OS", ",", "MCCodeEmitter", "*", "Emitter", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", "RelaxAll", ",", "bool", "NoExecStack", ")", "{", "return", "new", "MipsELFStreamer", "(", "Context", ",", "MAB", ",", "OS", ",", "Emitter", ",", "STI", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "offsetBits", ";", "let", "isPredicatedNew", "=", "isPredNew", ";", "let", "isPredicatedFalse", "=", "isPredNot", ";", "string", "ImmOpStr", "=", "!", "cast", "<", "string", ">", "(", "ImmOp", ")", ";", "let", "offsetBits", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ";", "let", "hasNewValue", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src2", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isPredNew", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isPredNot", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offsetBits", ";" ]

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

[ "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "SubtargetPredicate", "=", "ds", ".", "SubtargetPredicate", ";", "let", "AsmMatchConverter", "=", "ds", ".", "AsmMatchConverter", ";", "bits", "<", "<NUM_LIT>", ">", "vdst", ";", "bits", "<", "<NUM_LIT>", ">", "gds", ";", "bits", "<", "<NUM_LIT>", ">", "addr", ";", "bits", "<", "<NUM_LIT>", ">", "data0", ";", "bits", "<", "<NUM_LIT>", ">", "data1", ";", "bits", "<", "<NUM_LIT>", ">", "offset0", ";", "bits", "<", "<NUM_LIT>", ">", "offset1", ";" ]

[ "switch", "(", "Reg", ")", "{" ]

[ "static", "inline", "bool", "isARMArea3Register", "(", "unsigned", "Reg", ",", "bool", "isIOS", ")", "{", "using", "namespace", "ARM", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Sources", ".", "size", "(", ")", ";", "++", "i", ")", "ShuffleOps", "[", "i", "]", "=", "Sources", "[", "i", "]", ".", "ShuffleVec", ";" ]

[ "if", "(", "SrcEltTy", "==", "SmallestEltTy", ")", "continue", ";", "assert", "(", "ShuffleVT", ".", "getVectorElementType", "(", ")", "==", "SmallestEltTy", ")", ";", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "ShuffleVT", ",", "Src", ".", "ShuffleVec", ")", ";", "Src", ".", "WindowScale", "=", "SrcEltTy", ".", "getSizeInBits", "(", ")", "/", "SmallestEltTy", ".", "getSizeInBits", "(", ")", ";", "Src", ".", "WindowBase", "*=", "Src", ".", "WindowScale", ";", "}", "DEBUG", "(", "for", "(", "auto", "Src", ":", "Sources", ")", "assert", "(", "Src", ".", "ShuffleVec", ".", "getValueType", "(", ")", "==", "ShuffleVT", ")", ";", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "ShuffleVT", ".", "getVectorNumElements", "(", ")", ",", "-", "<NUM_LIT>", ")", ";", "int", "BitsPerShuffleLane", "=", "ShuffleVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "VT", ".", "getVectorNumElements", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Entry", "=", "Op", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Entry", ".", "isUndef", "(", ")", ")", "continue", ";", "auto", "Src", "=", "find", "(", "Sources", ",", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "int", "EltNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getSExtValue", "(", ")", ";", "EVT", "OrigEltTy", "=", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ";", "int", "BitsDefined", "=", "std", "::", "min", "(", "OrigEltTy", ".", "getSizeInBits", "(", ")", ",", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ";", "int", "LanesDefined", "=", "BitsDefined", "/", "BitsPerShuffleLane", ";", "int", "*", "LaneMask", "=", "&", "Mask", "[", "i", "*", "ResMultiplier", "]", ";", "int", "ExtractBase", "=", "EltNo", "*", "Src", "->", "WindowScale", "+", "Src", "->", "WindowBase", ";", "ExtractBase", "+=", "NumElts", "*", "(", "Src", "-", "Sources", ".", "begin", "(", ")", ")", ";", "for", "(", "int", "j", "=", "<NUM_LIT>", ";", "j", "<", "LanesDefined", ";", "++", "j", ")", "LaneMask", "[", "j", "]", "=", "ExtractBase", "+", "j", ";", "}", "if", "(", "!", "isShuffleMaskLegal", "(", "Mask", ",", "ShuffleVT", ")", ")", "return", "SDValue", "(", ")", ";", "assert", "(", "Sources", ".", "size", "(", ")", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Too many sources!", "<STR_LIT>", ")", ";", "SDValue", "ShuffleOps", "[", "]", "=", "{", "DAG", ".", "getUNDEF", "(", "ShuffleVT", ")", ",", "DAG", ".", "getUNDEF", "(", "ShuffleVT", ")", "}", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "const", "{" ]

[ "bool", "hasPushPop", "(", ")" ]

[ "call_used_regs", "[", "regno", "+", "<NUM_LIT>", "]", ")", ")", "{" ]

[ "for", "(", "regno", "=", "FIRST_VFP_REGNUM", ";", "regno", "<", "LAST_VFP_REGNUM", ";", "regno", "+=", "<NUM_LIT>", ")", "{", "if", "(", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "||", "call_used_regs", "[", "regno", "]", ")", "&&", "(", "!", "df_regs_ever_live_p", "(", "regno", "+", "<NUM_LIT>", ")", "||" ]

[ ")" ]

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

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

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseRegOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode" ]

[ "<FIXS>", "case", "ISD", "::", "XOR", ":", "return", "PerformXORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "<FIXE>" ]

[ "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "<BUGS>", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "<BUGE>", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBFICombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";" ]

[ "}" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Candidate MOV_32_64 instruction:", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "dump", "(", ")", ")", ";", "if", "(", "!", "isMovFrom32Def", "(", "&", "MI", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Removing the MOV_32_64 instruction\\n", "<STR_LIT>", ")", ";", "Register", "dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "src", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "dst", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "src", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "ToErase", "=", "&", "MI", ";", "Eliminated", "=", "true", ";", "}", "}", "return", "Eliminated", ";" ]

[ "$", "rd", ",", "GPR32Opnd", ":", "$", "rt", ")", ",", "<NUM_LIT>", ">", ",", "ISA_MIPS3", ";" ]

[ "def", ":", "MipsInstAlias", "<", "<STR_LIT>", ",", "(", "DSRLV", "GPR64Opnd", ":", "$", "rd", ",", "GPR64Opnd", ":" ]

[ "}" ]

[ "if", "(", "LS2", ".", "isBottom", "(", ")", "||", "LS2", ".", "isProperty", "(", ")", ")", "return", "false", ";", "APInt", "A", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "LS2", ".", "size", "(", ")", ";", "++", "i", ")", "{", "LatticeCell", "RC", ";", "bool", "Eval", "=", "constToInt", "(", "LS2", ".", "Values", "[", "i", "]", ",", "A", ")", "&&", "evaluateORri", "(", "R1", ",", "A", ",", "Inputs", ",", "RC", ")", ";", "if", "(", "!", "Eval", ")", "return", "false", ";", "Result", ".", "meet", "(", "RC", ")", ";", "}", "return", "!", "Result", ".", "isBottom", "(", ")", ";" ]

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

[ "def", "FalseLanesUndef", ":", "FalseLanesEnum", "<" ]

[ "<FIXS>", "void", "BTFDebug", "::", "visitBasicType", "(", "const", "DIBasicType", "*", "BTy", ",", "uint32_t", "&", "TypeId", ")", "{", "<FIXE>" ]

[ "return", "Id", ";", "}", "<BUGS>", "void", "BTFDebug", "::", "visitBasicType", "(", "const", "DIBasicType", "*", "BTy", ")", "{", "<BUGE>", "uint32_t", "Encoding", "=", "BTy", "->", "getEncoding", "(", ")", ";", "if", "(", "Encoding", "!=", "dwarf", "::", "DW_ATE_boolean", "&&", "Encoding", "!=", "dwarf", "::", "DW_ATE_signed", "&&" ]

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

[ "let", "Switches", "=", "sw", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "<NUM_LIT>", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "addr", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "fp", ")", ";", "<FIXE>" ]

[ "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_clobber", "(", "hard_frame_pointer_rtx", ")", ";", "emit_clobber", "(", "frame_pointer_rtx", ")", ";", "<BUGS>", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "fp", ",", "-", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "emit_use", "(", "hard_frame_pointer_rtx", ")", ";", "emit_use", "(", "stack_pointer_rtx", ")", ";" ]

[ "<FIXS>", "case", "Hexagon", "::", "S4_pstoreritnew_abs", ":", "<FIXE>", "<FIXS>", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "<FIXE>", "<FIXS>", "DecodeIntRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "case", "Hexagon", "::", "L4_ploadrdtnew_abs", ":", "<FIXE>", "<FIXS>", "DecodeDoubleRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "<FIXE>", "<FIXS>", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "case", "Hexagon", "::", "S4_pstorerif_abs", ":", "case", "Hexagon", "::", "S4_pstorerit_abs", ":", "case", "Hexagon", "::", "S4_pstorerifnew_abs", ":", "<BUGS>", "case", "Hexagon", "::", "S4_pstoreritnew_abs", ":", "{", "<BUGE>", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", ")", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "DecodeIntRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "break", ";", "<BUGS>", "}", "<BUGE>", "case", "Hexagon", "::", "L4_ploadrdf_abs", ":", "case", "Hexagon", "::", "L4_ploadrdt_abs", ":", "case", "Hexagon", "::", "L4_ploadrdfnew_abs", ":", "<BUGS>", "case", "Hexagon", "::", "L4_ploadrdtnew_abs", ":", "{", "<BUGE>", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "DecodeDoubleRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "Value", "=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "<BUGS>", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "Value", "=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "Value", "|=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", ")", ")", ";", "break", ";", "<BUGS>", "}", "<BUGE>", "case", "Hexagon", "::", "L4_ploadrbf_abs", ":", "case", "Hexagon", "::", "L4_ploadrbt_abs", ":" ]

[ "}" ]

[ "class", "EncodedI", "<", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "ARM64Inst", "<", "NormalFrm", ",", "cstr", ">", "{", "let", "Pattern", "=", "pattern", ";", "let", "Size", "=", "<NUM_LIT>", ";" ]

[ "sign_extend", "zero_extend", "]", ")" ]

[ "(", "define_code_iterator", "ANY_EXTEND", "[", "sign_extend", "zero_extend", "]", ")", "(", "define_code_iterator", "ANY_EXTEND2", "[" ]

[ "}" ]

[ "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>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "S", ",", "<STR_LIT>", "unexpected token in operand", "<STR_LIT>", ")", ";" ]

[ "OperandMatchResultTy", "ResTy", "=", "MatchOperandParserImpl", "(", "Operands", ",", "Mnemonic", ")", ";", "if", "(", "ResTy", "==", "MatchOperand_Success", ")", "return", "false", ";", "if", "(", "ResTy", "==", "MatchOperand_ParseFail", ")", "return", "true", ";", "switch", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", ")", "{", "default", ":", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "unexpected token in operand", "<STR_LIT>", ")", ";", "return", "true", ";", "case", "AsmToken", "::", "Identifier", ":", "{", "bool", "ExpectLabel", "=", "Mnemonic", "==", "<STR_LIT>", "b", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "bl", "<STR_LIT>", ";", "if", "(", "!", "ExpectLabel", ")", "{", "if", "(", "!", "tryParseRegisterWithWriteBack", "(", "Operands", ")", ")", "return", "false", ";", "int", "Res", "=", "tryParseShiftRegister", "(", "Operands", ")", ";", "if", "(", "Res", "==", "<NUM_LIT>", ")", "return", "false", ";", "else", "if", "(", "Res", "==", "-", "<NUM_LIT>", ")", "return", "true", ";", "if", "(", "Mnemonic", "==", "<STR_LIT>", "vmrs", "<STR_LIT>", "&&", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ".", "equals_insensitive", "(", "<STR_LIT>", "apsr_nzcv", "<STR_LIT>", ")", ")", "{", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "<STR_LIT>", "APSR_nzcv", "<STR_LIT>", ",", "S", ")", ")", ";", "return", "false", ";", "}", "}", "LLVM_FALLTHROUGH", ";", "}", "case", "AsmToken", "::", "LParen", ":", "case", "AsmToken", "::", "Integer", ":", "case", "AsmToken", "::", "String", ":", "case", "AsmToken", "::", "Dot", ":", "{", "const", "MCExpr", "*", "IdVal", ";", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "IdVal", ")", ")", "return", "true", ";", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateImm", "(", "IdVal", ",", "S", ",", "E", ")", ")", ";", "return", "false", ";", "}", "case", "AsmToken", "::", "LBrac", ":", "return", "parseMemory", "(", "Operands", ")", ";", "case", "AsmToken", "::", "LCurly", ":", "return", "parseRegisterList", "(", "Operands", ",", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "clr", "<STR_LIT>", ")", ")", ";", "case", "AsmToken", "::", "Dollar", ":", "case", "AsmToken", "::", "Hash", ":", "{", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "auto", "AdjacentToken", "=", "getLexer", "(", ")", ".", "peekTok", "(", "false", ")", ";", "bool", "ExpectIdentifier", "=", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Dollar", ")", "&&", "(", "AdjacentToken", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "||", "AdjacentToken", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", ";", "if", "(", "!", "ExpectIdentifier", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Colon", ")", ")", "{", "bool", "IsNegative", "=", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ";", "const", "MCExpr", "*", "ImmVal", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "ImmVal", ")", ")", "return", "true", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ImmVal", ")", ";", "if", "(", "CE", ")", "{", "int32_t", "Val", "=", "CE", "->", "getValue", "(", ")", ";", "if", "(", "IsNegative", "&&", "Val", "==", "<NUM_LIT>", ")", "ImmVal", "=", "MCConstantExpr", "::", "create", "(", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "min", "(", ")", ",", "getContext", "(", ")", ")", ";", "}", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateImm", "(", "ImmVal", ",", "S", ",", "E", ")", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Exclaim", ")", ")", "{", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ",", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "false", ";", "}", "LLVM_FALLTHROUGH", ";", "}", "case", "AsmToken", "::", "Colon", ":", "{", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "ARMMCExpr", "::", "VariantKind", "RefKind", ";", "if", "(", "parsePrefix", "(", "RefKind", ")", ")", "return", "true", ";", "const", "MCExpr", "*", "SubExprVal", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "SubExprVal", ")", ")", "return", "true", ";", "const", "MCExpr", "*", "ExprVal", "=", "ARMMCExpr", "::", "create", "(", "RefKind", ",", "SubExprVal", ",", "getContext", "(", ")", ")", ";", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateImm", "(", "ExprVal", ",", "S", ",", "E", ")", ")", ";", "return", "false", ";", "}", "case", "AsmToken", "::", "Equal", ":", "{", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "Mnemonic", "!=", "<STR_LIT>", "ldr", "<STR_LIT>", ")", "return", "Error", "(" ]

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

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

[ "unsigned", "ResultReg", "=", "createResultReg", "(", "DestVT", "==", "MVT", "::", "i32", "?", "&", "<STR_LIT>", "::", "<STR_LIT>", ":", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "MVT", "DestVT", ";", "if", "(", "!", "isTypeLegal", "(", "I", "->", "getType", "(", ")", ",", "DestVT", ")", "||", "DestVT", ".", "isVector", "(", ")", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "SrcReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "unsigned", "Opc", ";", "if", "(", "SrcVT", "==", "MVT", "::", "f64", ")", "{", "if", "(", "Signed", ")", "Opc", "=", "(", "DestVT", "==", "MVT", "::", "i32", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opc", "=", "(", "DestVT", "==", "MVT", "::", "i32", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "if", "(", "Signed", ")", "Opc", "=", "(", "DestVT", "==", "MVT", "::", "i32", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opc", "=", "(", "DestVT", "==", "MVT", "::", "i32", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_946df596", ",", "TypeALU64", ">", ",", "Enc_a56825", "{" ]

[ "def", "A2_orp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", "," ]

[ "}" ]

[ "++", "OpOffset", ";", "}", "castBufferRsrcArgToV4I32", "(", "MI", ",", "B", ",", "<NUM_LIT>", "+", "OpOffset", ")", ";", "Register", "RSrc", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getReg", "(", ")", ";", "const", "unsigned", "NumVIndexOps", "=", "IsTyped", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "const", "bool", "HasVIndex", "=", "MI", ".", "getNumOperands", "(", ")", "==", "NumVIndexOps", "+", "OpOffset", ";", "Register", "VIndex", ";", "if", "(", "HasVIndex", ")", "{", "VIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getReg", "(", ")", ";", "++", "OpOffset", ";", "}", "else", "{", "VIndex", "=", "B", ".", "buildConstant", "(", "S32", ",", "<NUM_LIT>", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "}", "Register", "VOffset", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getReg", "(", ")", ";", "Register", "SOffset", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getReg", "(", ")", ";", "unsigned", "Format", "=", "<NUM_LIT>", ";", "if", "(", "IsTyped", ")", "{", "Format", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getImm", "(", ")", ";", "++", "OpOffset", ";", "}", "unsigned", "AuxiliaryData", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getImm", "(", ")", ";", "unsigned", "ImmOffset", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "Dst", ")", ";", "if", "(", "hasBufferRsrcWorkaround", "(", "Ty", ")", ")", "{", "Ty", "=", "castBufferRsrcFromV4I32", "(", "MI", ",", "B", ",", "MRI", ",", "<NUM_LIT>", ")", ";", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "LLT", "EltTy", "=", "Ty", ".", "getScalarType", "(", ")", ";", "const", "bool", "IsD16", "=", "IsFormat", "&&", "(", "EltTy", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", ";", "const", "bool", "Unpacked", "=", "ST", ".", "hasUnpackedD16VMem", "(", ")", ";", "std", "::", "tie", "(", "VOffset", ",", "ImmOffset", ")", "=", "splitBufferOffsets", "(", "B", ",", "VOffset", ")", ";", "unsigned", "Opc", ";", "if", "(", "IsTyped", ")", "{", "if", "(", "IsTFE", ")", "return", "false", ";", "Opc", "=", "IsD16", "?", "AMDGPU", "::", "G_AMDGPU_TBUFFER_LOAD_FORMAT_D16", ":", "AMDGPU", "::", "G_AMDGPU_TBUFFER_LOAD_FORMAT", ";", "}", "else", "if", "(", "IsFormat", ")", "{", "if", "(", "IsD16", ")", "{", "if", "(", "IsTFE", ")", "return", "false", ";", "Opc", "=", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_FORMAT_D16", ";", "}", "else", "{", "Opc", "=", "IsTFE", "?", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_FORMAT_TFE", ":", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_FORMAT", ";", "}", "}", "else", "{", "if", "(", "IsTFE", ")", "return", "false", ";", "switch", "(", "MemTy", ".", "getSizeInBits", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "Opc", "=", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_UBYTE", ";", "break", ";", "case", "<NUM_LIT>", ":", "Opc", "=", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD_USHORT", ";", "break", ";", "default", ":", "Opc", "=", "AMDGPU", "::", "G_AMDGPU_BUFFER_LOAD", ";", "break", ";", "}" ]

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

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

[ "(", "label_ref", "(", "match_operand", "<NUM_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_operand", "<NUM_LIT>", ")" ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

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

[ "Result", "[", "Dst", "]", "=", "PVReg", ";" ]

[ "int", "LastDstChan", "=", "-", "<NUM_LIT>", ";", "do", "{", "bool", "isTrans", "=", "false", ";", "int", "BISlot", "=", "getSlot", "(", "*", "BI", ")", ";", "if", "(", "LastDstChan", ">=", "BISlot", ")", "isTrans", "=", "true", ";", "LastDstChan", "=", "BISlot", ";", "if", "(", "TII", "->", "isPredicated", "(", "*", "BI", ")", ")", "continue", ";", "int", "OperandIdx", "=", "TII", "->", "getOperandIdx", "(", "BI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "write", ")", ";", "if", "(", "OperandIdx", ">", "-", "<NUM_LIT>", "&&", "BI", "->", "getOperand", "(", "OperandIdx", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "continue", ";", "int", "DstIdx", "=", "TII", "->", "getOperandIdx", "(", "BI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst", ")", ";", "if", "(", "DstIdx", "==", "-", "<NUM_LIT>", ")", "{", "continue", ";", "}", "unsigned", "Dst", "=", "BI", "->", "getOperand", "(", "DstIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "isTrans", "||", "TII", "->", "isTransOnly", "(", "&", "*", "BI", ")", ")", "{", "Result", "[", "Dst", "]", "=", "AMDGPU", "::", "PS", ";", "continue", ";", "}", "if", "(", "BI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "DOT4_r600", "||", "BI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "DOT4_eg", ")", "{", "Result", "[", "Dst", "]", "=", "AMDGPU", "::", "PV_X", ";", "continue", ";", "}", "if", "(", "Dst", "==", "AMDGPU", "::", "OQAP", ")", "{", "continue", ";", "}", "unsigned", "PVReg", "=", "<NUM_LIT>", ";", "switch", "(", "TRI", ".", "getHWRegChan", "(", "Dst", ")", ")", "{", "case", "<NUM_LIT>", ":", "PVReg", "=", "AMDGPU", "::", "PV_X", ";", "break", ";", "case", "<NUM_LIT>", ":", "PVReg", "=", "AMDGPU", "::", "PV_Y", ";", "break", ";", "case", "<NUM_LIT>", ":", "PVReg", "=", "AMDGPU", "::", "PV_Z", ";", "break", ";", "case", "<NUM_LIT>", ":", "PVReg", "=", "AMDGPU", "::", "PV_W", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid Chan", "<STR_LIT>", ")", ";", "}" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "#", "include", "<STR_LIT>", "c-family/c-common.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "tm_p.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "config.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "system.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "coretypes.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "tm.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "alias.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "tree.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "options.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "tm_p.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "flags.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "c-family/c-common.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "target.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "cpplib.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "c-family/c-pragma.h", "<STR_LIT>", "static", "bool", "ix86_pragma_target_parse", "(", "tree", ",", "tree", ")", ";" ]

[ "_", "_", "B", ",", "(", "_", "_", "v4si", ")", "_", "_", "C", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpdpbusd_v4si", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")" ]

[ ";" ]

[ "for", "(", "const", "NodeSet", "&", "S", ":", "Rel", ")", "if", "(", "S", ".", "count", "(", "N", ")", ")", "return", "&", "S", ";", "return", "nullptr" ]

[ "static", "void", "annotate_constant_pool_refs", "(", "rtx", "*", "x", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "gcc_assert", "(", "GET_CODE", "(", "*", "x", ")", "!=", "SYMBOL_REF", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "*", "x", ")", ")", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "MEM", ")", "{", "rtx", "memref", "=", "XEXP", "(", "*", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "memref", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "memref", ")", ")", "{", "rtx", "base", "=", "cfun", "->", "machine", "->", "base_reg", ";", "rtx", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "memref", ",", "base", ")", ",", "UNSPEC_LTREF", ")", ";", "*", "x", "=", "replace_equiv_address", "(", "*", "x", ",", "addr", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "memref", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "{", "HOST_WIDE_INT", "off", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "sym", "=", "XEXP", "(", "XEXP", "(", "memref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "rtx", "base", "=", "cfun", "->", "machine", "->", "base_reg", ";", "rtx", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "sym", ",", "base", ")", ",", "UNSPEC_LTREF", ")", ";", "*", "x", "=", "replace_equiv_address", "(", "*", "x", ",", "plus_constant", "(", "addr", ",", "off", ")", ")", ";", "return", ";", "}", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "SET", ")", "{", "rtx", "addrref", "=", "SET_SRC", "(", "*", "x", ")", ";", "if", "(", "GET_CODE", "(", "addrref", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "addrref", ")", ")", "{", "rtx", "base", "=", "cfun", "->", "machine", "->", "base_reg", ";", "rtx", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "addrref", ",", "base", ")", ",", "UNSPEC_LTREF", ")", ";", "SET_SRC", "(", "*", "x", ")", "=", "addr", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "addrref", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "{", "HOST_WIDE_INT", "off", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "sym", "=", "XEXP", "(", "XEXP", "(", "addrref", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "rtx", "base", "=", "cfun", "->", "machine", "->", "base_reg", ";", "rtx", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "sym", ",", "base", ")", ",", "UNSPEC_LTREF", ")", ";", "SET_SRC", "(", "*", "x", ")", "=", "plus_constant", "(", "addr", ",", "off", ")", ";", "return", ";", "}", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LTREL_BASE", ")", "{", "rtx", "base", "=", "cfun", "->", "machine", "->", "base_reg", ";", "*", "x", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "XVECEXP", "(", "*", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "base", ")", ",", "UNSPEC_LTREL_BASE", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "*", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "*", "x", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", ")", "{", "annotate_constant_pool_refs", "(", "&", "XEXP", "(", "*", "x", ",", "i", ")", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "{", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<", "XVECLEN", "(", "*", "x", ",", "i", ")", ";", "j", "++", ")", "annotate_constant_pool_refs", "(", "&", "XVECEXP", "(", "*", "x", ",", "i", ",", "j", ")", ")", ";", "}", "}", "}" ]

[ "Annotate", "every", "literal", "pool", "reference", "in", "X", "by", "an", "UNSPEC_LTREF", "expression", ".", "Fix", "up", "MEMs", "as", "required", "." ]

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

[ "def", "J4_tstbit0_f_jumpnv_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_8c945be0", ",", "TypeNCJ", ">", ",", "Enc_69d63b", "{", "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>", ";" ]

[ "else", "{" ]

[ "static", "void", "xtensa_asm_trampoline_template", "(", "FILE", "*", "stream", ")", "{", "bool", "use_call0", "=", "(", "TARGET_CONST16", "||", "TARGET_ABSOLUTE_LITERALS", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\t.begin no-transform\\n", "<STR_LIT>", ")", ";", "if", "(", "TARGET_WINDOWED_ABI", ")", "{", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tentry\\tsp, %d\\n", "<STR_LIT>", ",", "MIN_FRAME_SIZE", ")", ";", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tmov\\ta10, a0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tcall0\\t.Lskipconsts\\n", "<STR_LIT>", ")", ";", "}", "else", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tj\\t.Lskipconsts\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\t.align\\t4\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", ".Lchainval:%s0\\n", "<STR_LIT>", ",", "integer_asm_op", "(", "<NUM_LIT>", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", ".Lfnaddr:%s0\\n", "<STR_LIT>", ",", "integer_asm_op", "(", "<NUM_LIT>", ",", "TRUE", ")", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", ".Lskipconsts:\\n", "<STR_LIT>", ")", ";", "if", "(", "use_call0", ")", "{", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\taddi\\ta0, a0, 3\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tl32i\\ta9, a0, 0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tl32i\\ta8, a0, 4\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tl32r\\ta9, .Lchainval\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tl32r\\ta8, .Lfnaddr\\n", "<STR_LIT>", ")", ";", "}", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\ts32i\\ta9, sp, %d\\n", "<STR_LIT>", ",", "MIN_FRAME_SIZE", "-", "<NUM_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tl32i\\ta9, a8, 0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\textui\\ta9, a9, %d, 12\\n", "<STR_LIT>", ",", "TARGET_BIG_ENDIAN", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tslli\\ta9, a9, 3\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\taddi\\ta9, a9, %d\\n", "<STR_LIT>", ",", "-", "MIN_FRAME_SIZE", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tsub\\ta9, sp, a9\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tmovsp\\tsp, a9\\n", "<STR_LIT>", ")", ";", "if", "(", "use_call0", ")", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tmov\\ta0, a10\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\taddi\\ta8, a8, 3\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tjx\\ta8\\n", "<STR_LIT>", ")", ";", "if", "(", "use_call0", ")", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\t.byte\\t0\\n", "<STR_LIT>", ")", ";", "else", "fprintf", "(", "stream", ",", "<STR_LIT>", "\\tnop\\n", "<STR_LIT>", ")", ";", "}" ]

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

[ "[", "(", "set", "(", "reg", ":", "<", "CC_EXTEND", ">", "CC_REGNUM", ")", "(", "compare", ":", "<", "CC_EXTEND", ">", "(", "SE", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "plus", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "SE", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>" ]

[ "let", "opNewValue", "=", "<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>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "||", "BRKIND", "(", "BRCFD", ")", "||", "BRKIND", "(", "BRCFS", ")", ";" ]

[ "using", "namespace", "llvm", "::", "VE", ";", "(", "Opc", "==", "NAME", "#", "#", "rr", "||", "Opc", "==", "NAME", "#", "#", "rr_nt", "||", "Opc", "==", "NAME", "#", "#", "rr_t", "||", "\\", "Opc", "==", "NAME", "#", "#", "ir", "||", "Opc", "==", "NAME", "#", "#", "ir_nt", "||", "Opc", "==", "NAME", "#", "#", "ir_t", ")", "return", "BRKIND", "(", "BRCFL", ")", "||", "BRKIND", "(", "BRCFW", ")" ]

[ "}", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "reg", ":", "CC", "CR6_REGNO", ")", "(", "unspec", ":", "CC", "[", "(", "eq", ":", "CC", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_PREDICATE", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "eq", ":", "V2DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq", ":", "SI", "(", "reg", ":", "CC", "CR6_REGNO", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "V2DImode", ")" ]

[ "}" ]

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

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_MOVSI_GOT", ")", ")", "]" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "addr", "|=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "reg", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "DecodeGPR8RegisterClass", "(", "Inst", ",", "reg", ",", "Address", ",", "Decoder", ")", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "addr", ")", ")", ";" ]

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

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "&", "PM", ")", "{" ]

[ "TargetPassConfig", "*", "BPFTargetMachine", "::", "createPassConfig", "(", "PassManagerBase" ]

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

[ "def", ":", "Pat", "(", "i64", "(", "int_aarch64_sme_get_tpidr2", ")", ")", ",", "(", "MRS", "<NUM_LIT>", ")", ">", ";", "<BUGS>", "}", "<BUGE>", "multiclass", "CoalescerBarrierPseudo", "RegisterClass", "rc", ",", "list", "ValueType", ">", "vts", ">", "{", "def", "NAME", ":", "Pseudo", "(", "outs", "rc", ":", "$", "dst", ")", ",", "(", "ins", "rc", ":", "$", "src", ")", ",", "[", "]", ">", ",", "Sched", "[", "]", ">", "{" ]

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

[ "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "R", ")", ")", "continue", ";", "if", "(", "MRI", "->", "getRegClass", "(", "R", ")", "!=", "&", "Hexagon", "::", "PredRegsRegClass", ")", "continue", ";", "for", "(", "auto", "U", "=", "MRI", "->", "use_begin", "(", "R", ")", ";", "U", "!=", "MRI", "->", "use_end", "(", ")", ";", "++", "U", ")", "if", "(", "U", "->", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "return", "false", ";", "}", "}" ]

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

[ "(", "define_code_attr", "optab", "[", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "]", ")", "(", "define_code_attr", "op", "[", "(", "and", "<STR_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", "hasNewValue" ]

[ "<FIXS>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "<FIXE>" ]

[ "}", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "QHSD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "\t", "<BUGE>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "\t", "\t", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]" ]

[ "<STR_LIT>", ")" ]

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

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

[ "def", "CondCode", ":", "AsmOperandClass", "{", "let", "Name" ]

[ "for", "(", "MachineInstr", "*", "DeadMI", ":", "DeadInstrs", ")", "DeadMI", "->", "eraseFromParent", "(", ")", ";" ]

[ "static", "void", "combineAwayG_UNMERGE_VALUES", "(", "LegalizationArtifactCombiner", "&", "ArtCombiner", ",", "MachineInstr", "&", "MI", ",", "GISelChangeObserver", "&", "Observer", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "UpdatedDefs", ";", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "DeadInstrs", ";", "ArtCombiner", ".", "tryCombineUnmergeValues", "(", "MI", ",", "DeadInstrs", ",", "UpdatedDefs", ",", "Observer", ")", ";" ]

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

[ "def", "J4_cmpeq_t_jumpnv_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "IntRegs", ":", "$", "Rt32", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_9bfd761f", ",", "TypeNCJ", ">", ",", "Enc_c9a18e", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "bool", "HexagonInstrInfo", "::", "isNewValueStore", "(", "unsigned", "Opcode", ")", "const", "{", "const", "uint64_t", "F", "=", "get", "(", "Opcode", ")", ".", "TSFlags", ";", "return", "(", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ ")", "{" ]

[ "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_SSE_REG_MODE", "(", "mode", ")", "||", "VALID_SSE2_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "MMX_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "mode", "==", "QImode" ]

[ "static", "void", "rs6000_darwin64_record_arg_advance_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "TREE_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "<NUM_LIT>", "&&", "host_integerp", "(", "bit_position", "(", "f", ")", ",", "<NUM_LIT>", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_advance_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ")", ";", "else", "if", "(", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ",", "ftype", ")", ")", "{", "rs6000_darwin64_record_arg_advance_flush", "(", "cum", ",", "bitpos", ")", ";", "cum", "->", "fregno", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "cum", "->", "words", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "}", "else", "if", "(", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "type", ",", "<NUM_LIT>", ")", ")", "{", "rs6000_darwin64_record_arg_advance_flush", "(", "cum", ",", "bitpos", ")", ";", "cum", "->", "vregno", "++", ";", "cum", "->", "words", "+=", "<NUM_LIT>", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "<NUM_LIT>", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}" ]

[ "The", "darwin64", "ABI", "calls", "for", "us", "to", "recurse", "down", "through", "structs", ",", "looking", "for", "elements", "passed", "in", "registers", ".", "Unfortunately", ",", "we", "have", "to", "track", "int", "register", "count", "here", "also", "because", "of", "misalignments", "in", "powerpc", "alignment", "mode", "." ]

[ "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "i64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "vis_fpsub64", "(", "_", "_", "i64", "_", "_", "A", ",", "_", "_", "i64", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_vis_fpsub64", "(", "_", "_", "A", ",", "_" ]

[ "}" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRnopcRegisterClass", "(", "Inst", ",", "Rt", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRnopcRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeAddrMode7Operand", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodePostIdxReg", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodePredicateOperand", "(", "Inst", ",", "Cond", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "S", ";" ]

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

[ "bool", "Changed", "=", "false", ";", "SmallSet", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "FillerInstrs", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Filling slots in BB#", "<STR_LIT>", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "<STR_LIT>", " (", "<STR_LIT>", "<<", "MBB", ".", "getFullName", "(", ")", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "hasDelaySlot", "(" ]

[ "V8SF", "V4DF", "]", ")" ]

[ "(", "define_mode_iterator", "V_256", "[", "V32QI", "V16HI", "V8SI", "V4DI" ]

[ "rs6000_add_stmt_cost", "(", "loop_vinfo", ",", "(", "void", "*", ")", "data", ",", "shift_cnt", ",", "scalar_stmt", ",", "NULL", ",", "NULL_TREE", ",", "<NUM_LIT>", ",", "vect_body", ")", ";" ]

[ "unsigned", "int", "shift_cnt", "=", "<NUM_LIT>", ";", "FOR_EACH_VEC_ELT", "(", "LOOP_VINFO_LENS", "(", "loop_vinfo", ")", ",", "num_vectors_m1", ",", "rgc", ")", "if", "(", "rgc", "->", "type", ")", "shift_cnt", "+=", "num_vectors_m1", "+", "<NUM_LIT>", ";" ]

[ "w12_15", ")", ";" ]

[ "return", "_", "_", "builtin_arm_crypto_sha256su1", "(", "_", "_", "tw0_3", ",", "_", "_", "w8_11", ",", "_", "_" ]