Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "fprintf", "(", "file", ",", "<STR_LIT>", " num_imm = %d, num_imm_32 = %d, num_imm_64 = %d, imm_size = %d\\n", "<STR_LIT>", ",", "list", "->", "num_imm", ",", "list", "->", "num_imm_32", ",", "list", "->", "num_imm_64", ",", "list", "->", "imm_size", ")", ";" ]

[ "int", "i", ";", "if", "(", "window_num", "==", "<NUM_LIT>", ")", "list", "=", "dispatch_window_list", ";", "else", "list", "=", "dispatch_window_list1", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "Window #%d:\\n", "<STR_LIT>", ",", "list", "->", "window_num", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", " num_insn = %d, num_uops = %d, window_size = %d\\n", "<STR_LIT>", ",", "list", "->", "num_insn", ",", "list", "->", "num_uops", ",", "list", "->", "window_size", ")", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V2DI", "[", "(", "match_operand" ]

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

[ "def", "A2_svaddh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

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

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

[ "(", "DF", "<STR_LIT>", ")", "(", "SD", "<STR_LIT>", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "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>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "scratch", ":", "SI", ")", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "<STR_LIT>" ]

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

[ "MachineInstr", "*", "BumpI", "=", "MRI", "->", "getVRegDef", "(", "I", "->", "first", ")", ";" ]

[ "MachineBasicBlock", "*", "TB", "=", "nullptr", ",", "*", "FB", "=", "nullptr", ";", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "Cond", ";", "bool", "NotAnalyzed", "=", "TII", "->", "analyzeBranch", "(", "*", "ExitingBlock", ",", "TB", ",", "FB", ",", "Cond", ",", "false", ")", ";", "if", "(", "NotAnalyzed", "||", "Cond", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "ExitingBlock", "!=", "Latch", "&&", "(", "TB", "==", "Latch", "||", "FB", "==", "Latch", ")", ")", "{", "MachineBasicBlock", "*", "LTB", "=", "nullptr", ",", "*", "LFB", "=", "nullptr", ";", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "LCond", ";", "bool", "NotAnalyzed", "=", "TII", "->", "analyzeBranch", "(", "*", "Latch", ",", "LTB", ",", "LFB", ",", "LCond", ",", "false", ")", ";", "if", "(", "NotAnalyzed", ")", "return", "false", ";", "if", "(", "TB", "==", "Latch", ")", "TB", "=", "(", "LTB", "==", "Header", ")", "?", "LTB", ":", "LFB", ";", "else", "FB", "=", "(", "LTB", "==", "Header", ")", "?", "LTB", ":", "LFB", ";", "}", "if", "(", "TB", "!=", "Header", ")", "{", "if", "(", "FB", "!=", "Header", ")", "{", "return", "false", ";", "}", "if", "(", "MDT", "->", "dominates", "(", "TB", ",", "FB", ")", ")", "return", "false", ";", "}", "unsigned", "CSz", "=", "Cond", ".", "size", "(", ")", ";", "if", "(", "CSz", "!=", "<NUM_LIT>", "&&", "CSz", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "!", "Cond", "[", "CSz", "-", "<NUM_LIT>", "]", ".", "isReg", "(", ")", ")", "return", "false", ";", "unsigned", "P", "=", "Cond", "[", "CSz", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "PredDef", "=", "MRI", "->", "getVRegDef", "(", "P", ")", ";", "if", "(", "!", "PredDef", "->", "isCompare", "(", ")", ")", "return", "false", ";", "SmallSet", "<", "unsigned", ",", "<NUM_LIT>", ">", "CmpRegs", ";", "MachineOperand", "*", "CmpImmOp", "=", "nullptr", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "PredDef", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "PredDef", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "if", "(", "MO", ".", "isUse", "(", ")", ")", "{", "if", "(", "!", "isImmediate", "(", "MO", ")", ")", "{", "CmpRegs", ".", "insert", "(", "MO", ".", "getReg", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "CmpImmOp", ")", "return", "false", ";", "CmpImmOp", "=", "&", "MO", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "if", "(", "CmpImmOp", ")", "return", "false", ";", "CmpImmOp", "=", "&", "MO", ";", "}", "}", "if", "(", "CmpRegs", ".", "empty", "(", ")", ")", "return", "false", ";", "for", "(", "RegisterInductionSet", "::", "iterator", "I", "=", "IndRegs", ".", "begin", "(", ")", ",", "E", "=", "IndRegs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "CmpRegs", ".", "count", "(", "I", "->", "first", ")", ")", "return", "true", ";", "const", "RegisterBump", "&", "RB", "=", "I", "->", "second", ";", "if", "(", "CmpRegs", ".", "count", "(", "RB", ".", "first", ")", ")", "{", "if", "(", "!", "CmpImmOp", ")", "{", "MachineInstr", "*", "IndI", "=", "nullptr", ";", "MachineInstr", "*", "nonIndI", "=", "nullptr", ";", "MachineOperand", "*", "IndMO", "=", "nullptr", ";", "MachineOperand", "*", "nonIndMO", "=", "nullptr", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "PredDef", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "PredDef", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "RB", ".", "first", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n DefMI(", "<STR_LIT>", "<<", "i", "<<", "<STR_LIT>", ") = ", "<STR_LIT>", "<<", "*", "(", "MRI", "->", "getVRegDef", "(", "I", "->", "first", ")", ")", ")", ";", "if", "(", "IndI", ")", "return", "false", ";", "IndI", "=", "MRI", "->", "getVRegDef", "(", "I", "->", "first", ")", ";", "IndMO", "=", "&", "MO", ";", "}", "else", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n DefMI(", "<STR_LIT>", "<<", "i", "<<", "<STR_LIT>", ") = ", "<STR_LIT>", "<<", "*", "(", "MRI", "->", "getVRegDef", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ";", "if", "(", "nonIndI", ")", "return", "false", ";", "nonIndI", "=", "MRI", "->", "getVRegDef", "(", "MO", ".", "getReg", "(", ")", ")", ";", "nonIndMO", "=", "&", "MO", ";", "}", "}", "if", "(", "IndI", "&&", "nonIndI", "&&", "nonIndI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "A2_addi", "&&", "nonIndI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "nonIndI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "-", "RB", ".", "second", ")", "{", "bool", "Order", "=", "or", "derBumpCompare", "(", "IndI", ",", "PredDef", ")", ";", "if", "(", "Order", ")", "{", "IndMO", "->", "setReg", "(", "I", "->", "first", ")", ";", "nonIndMO", "->", "setReg", "(", "nonIndI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "Comparison", "::", "Kind", "Cmp", "=", "getComparisonKind", "(", "PredDef", "->", "getOpcode", "(", ")", ",", "nullptr", ",", "nullptr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "Cmp", "||", "Comparison", "::", "isUnsigned", "(", "Cmp", ")", ")", "return", "false", ";", "int64_t", "CmpImm", "=", "getImmediate", "(", "*", "CmpImmOp", ")", ";", "int64_t", "V", "=", "RB", ".", "second", ";", "if", "(", "(", "(", "V", ">", "<NUM_LIT>", ")", "&&", "(", "CmpImm", ">", "INT64_MAX", "-", "V", ")", ")", "||", "(", "(", "V", "<", "<NUM_LIT>", ")", "&&", "(", "CmpImm", "<", "INT64_MIN", "-", "V", ")", ")", ")", "return", "false", ";", "CmpImm", "+=", "V", ";", "if", "(", "CmpImmOp", "->", "isImm", "(", ")", ")", "if", "(", "!", "isImmValidForOpcode", "(", "PredDef", "->", "getOpcode", "(", ")", ",", "CmpImm", ")", ")", "return", "false", ";" ]

[ "len", "+=", "<NUM_LIT>", "+", "(", "n", ">", "<NUM_LIT>", ")", "+", "(", "n", ">", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "len", "==", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "\\tdb ", "<STR_LIT>", ";", "if", "(", "n", ">=", "<NUM_LIT>", "&&", "n", "<=", "<NUM_LIT>", ")", "{", "if", "(", "!", "inString", ")", "{", "if", "(", "len", ">", "<NUM_LIT>", ")", "{", "O", "<<", "<STR_LIT>", ",'", "<STR_LIT>", ";", "len", "+=", "<NUM_LIT>", ";", "}", "else", "{", "O", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "len", "++", ";", "}", "inString", "=", "true", ";", "}", "if", "(", "n", "==", "'", "\\'", "'", ")", "{", "O", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "len", "++", ";", "}", "O", "<<", "char", "(", "n", ")", ";", "}", "else", "{", "if", "(", "inString", ")", "{", "O", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "len", "++", ";", "inString", "=", "false", ";", "}", "if", "(", "len", ">", "<NUM_LIT>", ")", "{", "O", "<<", "<STR_LIT>", ",", "<STR_LIT>", ";", "len", "++", ";", "}", "O", "<<", "n", ";" ]

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

[ "(", "define_cond_exec", "[", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "int", "small_data_operand", "(", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym_ref", ";", "if", "(", "rs6000_sdata", "==", "SDATA_NONE", "||", "rs6000_sdata", "==", "SDATA_DATA", ")", "return", "<NUM_LIT>", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym_ref", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "!=", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "return", "<NUM_LIT>", ";", "else", "{", "rtx", "sum", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "HOST_WIDE_INT", "summand", ";", "summand", "=", "INTVAL", "(", "XEXP", "(", "sum", ",", "<NUM_LIT>" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "GPF", "[", "SF", "DF" ]

[ "}", ")" ]

[ "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_vinsertgl_internal_", "<", "mode", ">", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "else", "emit_insn", "(", "gen_vinsertgr_internal_", "<", "mode", ">", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE" ]

[ "if", "(", "STACK_REG_P", "(", "a", ")", "||", "STACK_REG_P", "(", "b", ")", ")", "{" ]

[ "if", "(", "decl", ")", "func", "=", "decl", ";", "else", "{", "func", "=", "TREE_TYPE", "(", "TREE_OPERAND", "(", "exp", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "func", ")", ")", "func", "=", "TREE_TYPE", "(", "func", ")", ";", "}", "a", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "func", ",", "false", ")", ";", "b", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";" ]

[ "if", "(", "opy_p", "&&", "sched_mem_operand_p", "(", "insn", ",", "false", ")", ")", "return", "sched_get_operand", "(", "insn", ",", "false", ")", ";" ]

[ "opy_p", "=", "true", ";", "}", "if", "(", "must_write_p", ")", "{", "opx_p", "=", "true", ";", "opy_p", "=", "false", ";", "}" ]

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

[ "printOperand", "(", "MI", ",", "Op", "+", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", ":", "'", ";", "}", "O", "<<", "<STR_LIT>", "(", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "Op", ",", "O", ")", ";", "O", "<<", "<STR_LIT>" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "STORENT_MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "STORENT_MODE", "[", "(", "match_operand", ":", "STORENT_MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGS>", "UNSPEC_MOVNT", ")", ")", "]", ")", "<BUGE>" ]

[ "<FIXS>", "addr", "=", "plus_constant", "(", "Pmode", ",", "src", ",", "(", "srcoffset", "+", "j", "*", "UNITS_PER_WORD", "-", "src_autoinc", ")", ")", ";", "<FIXE>" ]

[ "{", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "interleave_factor", ";", "j", "++", ")", "{", "<BUGS>", "addr", "=", "plus_constant", "(", "src", ",", "srcoffset", "+", "j", "*", "UNITS_PER_WORD", "-", "src_autoinc", ")", ";", "<BUGE>", "mem", "=", "adjust_automodify_address", "(", "srcbase", ",", "SImode", ",", "addr", ",", "srcoffset", "+", "j", "*", "UNITS_PER_WORD", ")", ";", "emit_insn", "(", "gen_unaligned_loadsi", "(", "regs", "[", "j", "]", ",", "mem", ")", ")", ";" ]

[ ";" ]

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

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

[ "(", "neg", ":", "DF", "(", "mult", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

[ "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";" ]

[ "}", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "GP_REGNUM_P", "(", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "'", "M", "'", ":", "case", "'", "m", "'", ":", "{", "int", "cond_code", ";", "if", "(", "x", "==", "const_true_rtx", ")", "{", "if", "(", "code", "==", "'", "M", "'", ")", "fputs", "(", "<STR_LIT>", "nv", "<STR_LIT>", ",", "f", ")", ";", "return", ";", "}", "if", "(", "!", "COMPARISON_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "cond_code", "=", "aarch64_get_condition_code", "(", "x", ")", ";", "gcc_assert", "(", "cond_code", ">=", "<NUM_LIT>", ")", ";", "if", "(", "code", "==", "'", "M", "'", ")", "cond_code", "=", "AARCH64_INVERSE_CONDITION_CODE", "(", "cond_code", ")", ";", "fputs", "(", "aarch64_condition_codes", "[", "cond_code", "]", ",", "f", ")", ";", "}", "break", ";", "case", "'", "N", "'", ":", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid vector constant", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_VECTOR_INT", ")", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%wd", "<STR_LIT>", ",", "-", "INTVAL", "(", "elt", ")", ")", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_VECTOR_FLOAT", "&&", "aarch64_print_vector_float_operand", "(", "f", ",", "x", ",", "true", ")", ")", ";", "else", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid vector constant", "<STR_LIT>", ")", ";", "return", ";", "}", "break", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "s", "'", ":", "case", "'", "d", "'", ":", "case", "'", "q", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%c%d", "<STR_LIT>", ",", "code", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", ")", ";", "break", ";", "case", "'", "S", "'", ":", "case", "'", "T", "'", ":", "case", "'", "U", "'", ":", "case", "'", "V", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%c%d", "<STR_LIT>", ",", "aarch64_sve_data_mode_p", "(", "GET_MODE", "(", "x", ")", ")", "?", "'", "z", "'", ":", "'", "v", "'", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", "+", "(", "code", "-", "'", "S", "'", ")", ")", ";", "break", ";", "case", "'", "R", "'", ":", "if", "(", "!", "REG_P", "(", "x", ")", "||", "!", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "incompatible floating point / vector register operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "q%d", "<STR_LIT>", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", "+", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "X", "'", ":", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "UINTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "C", "'", ":", "{", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "||", "!", "CONST_INT_P", "(", "elt", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "scalar_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "GET_MODE", "(", "x", ")", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "UINTVAL", "(", "elt", ")", "&", "GET_MODE_MASK", "(", "inner_mode", ")", ")", ";", "}", "break", ";", "case", "'", "D", "'", ":", "{", "if", "(", "!", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "||", "!", "CONST_INT_P", "(", "elt", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "code", ")", ";", "return", ";", "}", "scalar_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "GET_MODE", "(", "x", ")", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%wd", "<STR_LIT>", ",", "UINTVAL", "(", "elt", ")", "&", "GET_MODE_MASK", "(", "inner_mode", ")", ")", ";", "}", "break", ";", "case", "'", "w", "'", ":", "case", "'", "x", "'", ":", "if", "(", "x", "==", "const0_rtx", "||", "(", "CONST_DOUBLE_P", "(", "x", ")", "&&", "aarch64_float_const_zero_rtx_p", "(", "x", ")", ")", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%czr", "<STR_LIT>", ",", "code", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "GP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%c%d", "<STR_LIT>", ",", "code", ",", "REGNO", "(", "x", ")", "-", "R0_REGNUM", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "SP_REGNUM", ")", "{", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%ssp", "<STR_LIT>", ",", "code", "==", "'", "w", "'", "?", "<STR_LIT>", "w", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ";", "break", ";", "}", "case", "<NUM_LIT>", ":", "if", "(", "x", "==", "NULL", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "missing operand", "<STR_LIT>", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "aarch64_sve_data_mode_p", "(", "GET_MODE", "(", "x", ")", ")", ")", "{", "if", "(", "REG_NREGS", "(", "x", ")", "==", "<NUM_LIT>", ")", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "z%d", "<STR_LIT>", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", ")", ";", "else", "{", "char", "suffix", "=", "sizetochar", "(", "GET_MODE_UNIT_BITSIZE", "(", "GET_MODE", "(", "x", ")", ")", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "{z%d.%c - z%d.%c}", "<STR_LIT>", ",", "REGNO", "(", "x", ")", "-", "V0_REGNUM", ",", "suffix", ",", "END_REGNO", "(", "x", ")", "-", "V0_REGNUM", "-", "<NUM_LIT>", ",", "suffix", ")", ";", "}", "}", "else", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":" ]

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

[ "return", "_", "_", "builtin_mve_vandq_m_uv16qi", "(", "_", "_", "arm_vuninitializedq_u8", "(", ")", ",", "_", "_", "a", ",", "_", "_", "b", "," ]

[ "WasmSym", "->", "setWeak", "(", "true", ")", ";" ]

[ "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "<STR_LIT>", "__stack_pointer", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "strcmp", "(", "Name", ",", "<STR_LIT>", "__tls_base", "<STR_LIT>", ")", "==", "<NUM_LIT>", ";", "WasmSym", "->", "setType", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "WasmSym", "->", "setGlobalType", "(", "<STR_LIT>", "::", "<STR_LIT>", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ">", "Returns", ";", "SmallVector", "<", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "<STR_LIT>", "__cpp_exception", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "WasmSym", "->", "setType", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ ".", "hasOneNonDBGUse", "(", "MI1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "return", "true", ";" ]

[ "if", "(", "Commuted", ")", "std", "::", "swap", "(", "MI1", ",", "MI2", ")", ";", "if", "(", "MI1", "->", "getOpcode", "(", ")", "==", "AssocOpcode", "&&", "hasReassociableOperands", "(", "*", "MI1", ",", "MBB", ")", "&&", "MRI" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "FractPart", ")", ";" ]

[ "SDValue", "FractPart", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Arg", ",", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "/", "M_PI", ",", "VT", ")", ")", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FCOS", ":" ]

[ "BitVector", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "assert", "(", "!", "<STR_LIT>", "Unimplemented", "<STR_LIT>", ")", ";", "return", "BitVector", "(", ")", ";", "}" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

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

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

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

[ "void", "csky_init_expanders", "(" ]

[ "CSR_RegMask", ";" ]

[ "const", "uint32_t", "*", "SparcRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return" ]

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

[ "return", "_", "_", "builtin_mve_vcvtq_m_to_f_uv8hf", "(", "_", "_", "arm_vuninitializedq_f16", "(", ")", ",", "_", "_", "a" ]

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

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

[ "}" ]

[ "bool", "isGP64", "(", ")", "const", "{", "return", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureGP64Bit", ")", "!=", "<NUM_LIT>", ";" ]

[ "const", "Value", "*", "DstSV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerVACOPY", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "assert", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "<STR_LIT>", "This code only handles 64-bit va_copy!", "<STR_LIT>", ")", ";", "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "DstPtr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "SrcPtr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

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

[ "if", "(", "!", "Before", ")", "++", "MI", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Wbinvl1Opcode", ")", ")", ";", "if", "(", "!", "Before", ")", "--", "MI", ";" ]

[ "SDValue", "Ops", "[", "<NUM_LIT>", "]", "=", "{", "Lo", ",", "Hi", "}", ";" ]

[ "SDValue", "Tmp1", "=", "isSRA", "?", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "VT", ",", "ShOpHi", ",", "DAG", ".", "getConstant", "(", "VTBits", "-", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ":", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "VT", ")", ";", "SDValue", "Tmp2", ",", "Tmp3", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL_PARTS", ")", "{", "Tmp2", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "ShOpHi", ",", "ShOpLo", ",", "ShAmt", ")", ";", "Tmp3", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "VT", ",", "ShOpLo", ",", "SafeShAmt", ")", ";", "}", "else", "{", "Tmp2", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "ShOpLo", ",", "ShOpHi", ",", "ShAmt", ")", ";", "Tmp3", "=", "DAG", ".", "getNode", "(", "isSRA", "?", "ISD", "::", "SRA", ":", "ISD", "::", "SRL", ",", "dl", ",", "VT", ",", "ShOpHi", ",", "SafeShAmt", ")", ";", "}", "SDValue", "AndNode", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i8", ",", "ShAmt", ",", "DAG", ".", "getConstant", "(", "VTBits", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Cond", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "AndNode", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Hi", ",", "Lo", ";", "SDValue", "CC", "=", "DAG", ".", "getConstant", "(", "X86", "::", "COND_NE", ",", "MVT", "::", "i8", ")", ";", "SDValue", "Ops0", "[", "<NUM_LIT>", "]", "=", "{", "Tmp2", ",", "Tmp3", ",", "CC", ",", "Cond", "}", ";", "SDValue", "Ops1", "[", "<NUM_LIT>", "]", "=", "{", "Tmp3", ",", "Tmp1", ",", "CC", ",", "Cond", "}", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL_PARTS", ")", "{", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ops0", ",", "<NUM_LIT>", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ops1", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ops0", ",", "<NUM_LIT>", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ops1", ",", "<NUM_LIT>", ")", ";", "}" ]

[ ",", "Subtarget", ")", ";" ]

[ "return", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "Triple", "::", "MachO", ":", "return", "LowerGlobalAddressDarwin", "(", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "LowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "LowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETUP_DISPATCH", ":", "return", "LowerEH_SJLJ_SETUP_DISPATCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "ExpandBITCAST", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShift", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SREM", ":", "return", "LowerREM", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "UREM", ":", "return", "LowerREM", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "return", "LowerCTTZ", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerVSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "LowerConstantFP", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG" ]

[ "}" ]

[ "Value", "*", "Ptr", "=", "BasePtr", ";", "if", "(", "Offset", ")", "Ptr", "=", "IRB", ".", "CreateConstGEP1_32", "(", "Ptr", ",", "Offset", ")", ";", "IRB", ".", "CreateCall", "(", "SetTagZeroFn", ",", "{", "Ptr", ",", "ConstantInt", "::", "get", "(", "IRB", ".", "getInt64Ty", "(", ")", ",", "Size", ")", "}", ")", ";" ]

[ ",", "DAG", ")", ")", ";" ]

[ "const", "StructLayout", "*", "SL", "=", "TD", ".", "getStructLayout", "(", "ST", ")", ";", "EVT", "PtrVT", "=", "InitPtr", ".", "getValueType", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Chains", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "N", "=", "ST", "->", "getNumElements", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "{", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "SL", "->", "getElementOffset", "(", "I", ")", ",", "DL", ",", "PtrVT", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "InitPtr", ",", "Offset", ")", ";", "Constant", "*", "Elt", "=", "Init", "->", "getAggregateElement", "(", "I", ")", ";", "Chains", ".", "push_back", "(", "LowerConstantInitializer", "(", "Elt", ",", "GV", ",", "Ptr", ",", "Chain", ",", "DAG", ")", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Chains", ")", ";", "}", "if", "(", "SequentialType", "*", "SeqTy", "=", "dyn_cast", "<", "SequentialType", ">", "(", "InitTy", ")", ")", "{", "EVT", "PtrVT", "=", "InitPtr", ".", "getValueType", "(", ")", ";", "unsigned", "NumElements", ";", "if", "(", "ArrayType", "*", "AT", "=", "dyn_cast", "<", "ArrayType", ">", "(", "SeqTy", ")", ")", "NumElements", "=", "AT", "->", "getNumElements", "(", ")", ";", "else", "if", "(", "VectorType", "*", "VT", "=", "dyn_cast", "<", "VectorType", ">", "(", "SeqTy", ")", ")", "NumElements", "=", "VT", "->", "getNumElements", "(", ")", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected type", "<STR_LIT>", ")", ";", "unsigned", "EltSize", "=", "TD", ".", "getTypeAllocSize", "(", "SeqTy", "->", "getElementType", "(", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Chains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumElements", ";", "++", "i", ")", "{", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "i", "*", "EltSize", ",", "DL", ",", "PtrVT", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "InitPtr", ",", "Offset", ")", ";", "Constant", "*", "Elt", "=", "Init", "->", "getAggregateElement", "(", "i", ")", ";", "Chains", ".", "push_back", "(", "LowerConstantInitializer", "(", "Elt", ",", "GV", ",", "Ptr", ",", "Chain" ]

[ "$", "rB", ",", "crbitrc", ":", "$", "cond", ")", ",", "<STR_LIT>", ",", "IIC_IntGeneral", ",", "[", "]", ">", ";" ]

[ "def", "ISEL8", ":", "AForm_4", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "g8rc", ":", "$", "rT", ")", ",", "(", "ins", "g8rc_nox0", ":", "$", "rA", ",", "g8rc", ":" ]

[ "}" ]

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

[ "mm512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_load_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "void", "const", "*", "_", "_", "P", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_loadapd512_mask", "(", "(", "const", "_", "_", "v8df", "*", ")", "_", "_", "P", ",", "(", "_", "_", "v8df", ")", "_" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<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>" ]

[ "static", "int", "vax_address_cost_1", "(", "rtx", "addr", ")", "{", "int", "reg", "=", "<NUM_LIT>", ",", "indexed", "=", "<NUM_LIT>", ",", "indir", "=", "<NUM_LIT>", ",", "offset", "=", "<NUM_LIT>", ",", "predec", "=", "<NUM_LIT>", ";", "rtx", "plus_op0", "=", "<NUM_LIT>", ",", "plus_op1", "=", "<NUM_LIT>", ";", "restart", ":", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "predec", "=", "<NUM_LIT>", ";", "case", "REG", ":", "case", "SUBREG", ":", "case", "POST_INC", ":", "reg", "=", "<NUM_LIT>", ";", "break", ";", "case", "MULT", ":", "case", "ASHIFT", ":", "indexed", "=", "<NUM_LIT>", ";", "break", ";", "case", "CONST_INT", ":", "if", "(", "offset", "==", "<NUM_LIT>", ")", "offset", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "INTVAL", "(", "addr", ")", "+", "<NUM_LIT>", ")", ">", "<NUM_LIT>", ";", "break", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "offset", "=", "<NUM_LIT>", ";", "break", ";", "case", "LABEL_REF", ":", "if", "(", "offset", "==", "<NUM_LIT>", ")", "offset", "=", "<NUM_LIT>", ";", "break", ";", "case", "PLUS", ":", "if", "(", "plus_op0", ")", "plus_op1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "else", "plus_op0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "goto", "restart", ";", "case", "MEM", ":", "indir", "=", "<NUM_LIT>", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "goto", "restart", ";", "default", ":", "break", ";", "}", "if", "(", "plus_op0", ")", "{", "addr", "=", "plus_op0", ";", "plus_op0", "=", "<NUM_LIT>", ";", "goto", "restart", ";", "}", "if", "(", "plus_op1", ")", "{", "addr", "=", "plus_op1", ";", "plus_op1", "=", "<NUM_LIT>", ";", "goto", "restart", ";", "}", "if", "(", "reg", "&&", "indexed", "&&", "offset", ")", "return", "reg", "+", "indir", "+", "offset", "+", "predec", ";", "return", "reg", "+", "indexed", "+", "indir", "+", "offset", "+", "predec", ";", "}" ]

[ "Return", "the", "cost", "in", "cycles", "of", "a", "memory", "address", ",", "relative", "to", "register", "indirect", ".", "Each", "of", "the", "following", "adds", "the", "indicated", "number", "of", "cycles", ":", "1", "-", "symbolic", "address", "1", "-", "pre-decrement", "1", "-", "indexing", "and/or", "offset", "(", "register", ")", "2", "-", "indirect" ]

[ "}" ]

[ "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "ix86_in_large_data_p", "(", "decl", ")", ")", "flags", "|=", "SECTION_LARGE", ";", "if", "(", "decl", "==", "NULL_TREE", "&&", "(", "strcmp", "(", "name", ",", "<STR_LIT>", ".ldata.rel.ro", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "strcmp", "(", "name", ",", "<STR_LIT>", ".ldata.rel.ro.local", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "flags", "|=", "SECTION_RELRO", ";", "if", "(", "strcmp", "(", "name", ",", "<STR_LIT>", ".lbss", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "startswith", "(", "name", ",", "<STR_LIT>", ".lbss.", "<STR_LIT>", ")", "||", "startswith", "(", "name", ",", "<STR_LIT>", ".gnu.linkonce.lb.", "<STR_LIT>", ")", ")", "flags", "|=", "SECTION_BSS", ";", "return", "flags", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI" ]

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

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

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

[ "def", "PACGA", ":", "SignAuthTwoOperand", "<", "<NUM_LIT>", "," ]

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

[ "{", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "copy_to_mode_reg", "(", "QImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "rl78_far_p", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "rl78_far_p", "(", "operands" ]

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

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

[ "<STR_LIT>" ]

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

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

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "OpNode", "(", "v4i32", "V128", ":", "$", "LHS", ")", ",", "(", "v4i32", "V128", ":", "$", "MHS", ")", ",", "(", "v4i32", "V128", ":", "$", "RHS", ")", ")", ")" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<FIXE>" ]

[ "if", "(", "!", "nonimmediate_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "ix86_fixup_binary_operands_no_copy", "(", "code", ",", "mode", ",", "operands", ")", ";", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<BUGE>", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", ";", "}" ]

[ "}" ]

[ "else", "mode", "=", "DECL_MODE", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ";", "return", "GET_MODE_SIZE", "(", "mode", ")", ";" ]

[ "}" ]

[ "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "ArchP", "=", "ArchV", ".", "split", "(", "'", "t", "'", ")", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "CPUP", "=", "CPU", ".", "split", "(", "'", "t", "'", ")", ";", "if", "(", "!", "ArchP", ".", "first", ".", "equals", "(", "CPUP", ".", "first", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "conflicting architectures specified.", "<STR_LIT>", ")", ";", "return", "CPU", ";", "}", "if", "(", "ArchV", ".", "empty", "(", ")", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", ")", "CPU", "=", "DefaultArch", ";", "return", "CPU", ";", "}", "return", "ArchV", ";" ]

[ "FuncInfo", "->", "removeVGPRForSGPRSpill", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ",", "MF", ")", ";" ]

[ "unsigned", "FIOp", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "Register", "VReg", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", "->", "getReg", "(", ")", ";", "if", "(", "FuncInfo", "->", "allocateVGPRSpillToAGPR", "(", "MF", ",", "FI", ",", "TRI", "->", "isAGPR", "(", "MRI", ",", "VReg", ")", ")", ")", "{", "NewReservedRegs", "=", "true", ";", "if", "(", "!", "RS", ")", "RS", ".", "reset", "(", "new", "RegScavenger", "(", ")", ")", ";", "RS", "->", "enterBasicBlock", "(", "MBB", ")", ";", "TRI", "->", "eliminateFrameIndex", "(", "MI", ",", "<NUM_LIT>", ",", "FIOp", ",", "RS", ".", "get", "(", ")", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "continue", ";", "}", "}", "if", "(", "!", "TII", "->", "isSGPRSpill", "(", "MI", ")", "||", "!", "TRI", "->", "spillSGPRToVGPR", "(", ")", ")", "continue", ";", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "NewReservedRegs", "=", "true", ";", "bool", "Spilled", "=", "TRI", "->", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "nullptr", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "<STR_LIT>", "failed to spill SGPR to VGPR when allocated", "<STR_LIT>", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "}", "}", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "SSpill", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "SSpill", ".", "VGPR", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getVGPRSpillAGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getAGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "SpillFIs", "[", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", "]", ")", "{", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "ChangeToRegister", "(", "Register", "(", ")", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDebug", "(", ")", ";", "}", "}", "}", "MadeChange", "=", "true", ";", "}", "else", "if", "(", "FuncInfo", "->", "VGPRReservedForSGPRSpill", ")", "{" ]

[ ")" ]

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

[ ">", "(", ")", "->", "setHasCFIAdjustCfa", "(", "true", ")", ";" ]

[ "void", "X86FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "const", "MCCFIInstruction", "&", "CFIInst", ",", "MachineInstr", "::", "MIFlag", "Flag", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "CFIInst", ")", ";", "if", "(", "CFIInst", ".", "getOperation", "(", ")", "==", "MCCFIInstruction", "::", "OpAdjustCfaOffset", ")", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo" ]

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

[ "}", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "SI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_SX", ")", ")", "(", "set", "(", "match_operand", ":", "ALLI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "unsigned", "Value", "=", "-", "(", "unsigned", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "<FIXE>" ]

[ "def", "so_imm_neg_asmoperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "so_imm_neg", ":", "Operand", "i32", ">", ",", "PatLeaf", "(", "imm", ")", ",", "[", "{", "<BUGS>", "int64_t", "Value", "=", "-", "(", "int", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "<BUGE>", "return", "Value", "&", "&", "ARM_AM", ":", ":", "getSOImmVal", "(", "Value", ")", "!", "=", "-", "<NUM_LIT>", ";", "}", "]", ",", "imm_neg_XFORM", ">", "{", "let", "ParserMatchClass", "=", "so_imm_neg_asmoperand", ";" ]

[ "static", "bool", "s390_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "mode", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TLS_SYMBOLIC_CONST", "(", "op", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "flag_pic", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "=", "Unordered", ";" ]

[ "class", "relaxed_store", "<", "PatFrag", "base", ">", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ",", "node", ":", "$", "val", ")", ",", "(", "base", "node", ":", "$", "ptr", ",", "node", ":", "$", "val", ")", ",", "[", "{", "AtomicOrdering", "Ordering", "=", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "-", ">", "getOrdering", "(", ")", ";", "return", "Ordering", "=", "=", "Monotonic", "|", "|", "Ordering", "=" ]

[ ")", ";" ]

[ "void", "NodeAllocator", "::", "startNewBlock", "(", ")", "{", "void", "*", "T", "=", "MemPool", ".", "Allocate", "(", "NodesPerBlock", "*", "NodeMemSize", ",", "NodeMemSize", ")", ";", "char", "*", "P", "=", "static_cast", "<", "char", "*", ">", "(", "T", ")", ";", "Blocks", ".", "push_back", "(", "P" ]

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

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

[ "<STR_LIT>" ]

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

[ "LO16", "=", "LO16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "TF", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "MachineInstr", "*", "NewMI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NewLdOpc", ")", ",", "DstReg", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "NewMI", "->", "setMemRefs", "(", "MI", ".", "memoperands_begin", "(", ")", ",", "MI", ".", "memoperands_end", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "tPICADD", ")", ")", ".", "addReg", "(", "DstReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "DstReg", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "Modified", "=", "true", ";", "break", ";", "}", "case", "ARM", "::", "t2MOVi32imm", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineInstrBuilder", "LO16", ",", "HI16", ";", "LO16", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2MOVi16", ")", ",", "DstReg", ")", ";", "HI16", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2MOVTi16", ")", ")", ".", "addReg", "(", "DstReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "unsigned", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "unsigned", "Lo16", "=", "Imm", "&", "<NUM_LIT>", ";", "unsigned", "Hi16", "=", "(", "Imm", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "LO16", "=", "LO16", ".", "addImm", "(", "Lo16", ")", ";", "HI16", "=", "HI16", ".", "addImm", "(", "Hi16", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "addr", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "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", "=" ]

[ ")", ";" ]

[ "void", "AMDGPURedwoodDevice", "::", "setCaps", "(", ")", "{", "mSWBits", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>" ]

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

[ "def", ":", "WriteRes", "<", "WriteRMW", ",", "[" ]

[ ":" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "ST", "->", "isThumb1Only", "(", ")", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "&&", "VT", "==", "MVT", "::", "i32", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "hasOneUse", "(", ")", ")", "{", "if", "(", "DCI", ".", "isBeforeLegalize", "(", ")", "||", "DCI", ".", "isCalledByLegalizer", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "ConstantSDNode", "*", "ShiftAmtNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "ShiftAmtNode", ")", "return", "SDValue", "(", ")", ";", "uint32_t", "ShiftAmt", "=", "static_cast", "<", "uint32_t", ">", "(", "ShiftAmtNode", "->", "getZExtValue", "(", ")", ")", ";", "ConstantSDNode", "*", "AndMaskNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "AndMaskNode", ")", "return", "SDValue", "(", ")", ";", "uint32_t", "AndMask", "=", "static_cast", "<", "uint32_t", ">", "(", "AndMaskNode", "->", "getZExtValue", "(", ")", ")", ";", "if", "(", "AndMask", "==", "<NUM_LIT>", "||", "AndMask", "==", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "isMask_32", "(", "AndMask", ")", ")", "{", "uint32_t", "MaskedBits", "=", "countLeadingZeros", "(", "AndMask", ")", ";", "if", "(", "MaskedBits", ">", "ShiftAmt", ")", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "SHL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "MaskedBits", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "SHL", ",", "DAG", ".", "getConstant", "(", "MaskedBits", "-", "ShiftAmt", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "}", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "||", "!", "TLI", ".", "isTypeLegal", "(", "VT", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "ST", "->", "hasMVEIntegerOps", "(", ")", "&&", "VT", "==", "MVT", "::", "v2i64", ")", "return", "SDValue", "(", ")", ";", "int64_t", "Cnt", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected shift opcode", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SHL" ]

[ ")", ";" ]

[ "static", "bool", "finishStackBlock", "(", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "PendingMembers", ",", "MVT", "LocVT", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ",", "unsigned", "SlotAlign", ")", "{", "unsigned", "Size", "=", "LocVT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "const", "Align", "StackAlign", "=", "State", ".", "getMachineFunction", "(", ")", ".", "getDataLayout", "(", ")", ".", "getStackAlignment", "(", ")", ";", "const", "Align", "OrigAlign", "(", "ArgFlags", ".", "getOrigAlign", "(", ")", ")", ";", "const", "Align", "Align", "=", "std", "::", "min", "(", "OrigAlign", ",", "StackAlign", ")", ";", "for", "(", "auto", "&", "It", ":", "PendingMembers", ")", "{", "It", ".", "convertToMem", "(", "State", ".", "AllocateStack", "(", "Size", ",", "std", "::", "max", "(", "(", "unsigned", ")", "Align", ".", "value", "(", ")", ",", "SlotAlign", ")", ")", ")", ";", "State", ".", "addLoc", "(", "It", ")", ";", "SlotAlign", "=", "<NUM_LIT>", ";", "}", "PendingMembers", ".", "clear", "(" ]

[ "int", "s390_extra_constraint_str", "(", "rtx", "op", ",", "int", "c", ",", "const", "char", "*", "str", ")", "{", "struct", "s390_address", "addr", ";", "gcc_assert", "(", "c", "==", "str", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "c", "==", "'", "A", "'", ")", "{", "if", "(", "!", "MEM_P", "(", "op", ")", "||", "MEM_VOLATILE_P", "(", "op", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "reload_completed", "||", "reload_in_progress", ")", "?", "!", "offsettable_memref_p", "(", "op", ")", ":", "!", "offsettable_nonstrict_memref_p", "(", "op", ")", ")", "return", "<NUM_LIT>", ";", "c", "=", "str", "[", "<NUM_LIT>", "]", ";", "}", "else", "if", "(", "c", "==", "'", "B", "'", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "&", "addr", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "addr", ".", "literal_pool", ")", "return", "<NUM_LIT>", ";", "c", "=", "str", "[", "<NUM_LIT>", "]", ";", "}", "switch", "(", "c", ")", "{", "case", "'", "Q", "'", ":", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "&", "addr", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "addr", ".", "indx", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_LONG_DISPLACEMENT", ")", "{", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "'", "R", "'", ":", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_LONG_DISPLACEMENT", ")", "{", "if", "(", "!", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "&", "addr", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "'", "S", "'", ":", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "&", "addr", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "addr", ".", "indx", ")", "return", "<NUM_LIT>", ";", "if", "(", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "break", ";", "case", "'", "T", "'", ":", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "<NUM_LIT>", ";", "if", "(", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "&", "addr", ")", "&&", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "break", ";", "case", "'", "U", "'", ":", "if", "(", "TARGET_LONG_DISPLACEMENT", ")", "{", "if", "(", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "'", "W", "'", ":", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "<NUM_LIT>", ";", "if", "(", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", "&&", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "<NUM_LIT>", ";", "break", ";", "case", "'", "Y", "'", ":", "if", "(", "!", "s390_decompose_shift_count", "(", "op", ",", "NULL", ",", "NULL", ")", ")", "return", "<NUM_LIT>", ";", "break", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "OP", "is", "a", "valid", "operand", "for", "a", "C", "constraint", ",", "0", "else", "." ]

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

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

[ ";" ]

[ "MOp", "=", "MemOp", "::", "Set", "(", "Size", ",", "false", ",", "DstAlign", ",", "false", ",", "false", ")", ";", "DstAddrSpace", "=", "MS", "->", "getDestAddressSpace", "(", ")", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "Expected a memcpy/move or memset!", "<STR_LIT>", ")", ";", "unsigned", "Limit", ",", "Factor", "=", "<NUM_LIT>", ";", "switch", "(", "I", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "memcpy", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemcpy", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "break", ";", "case", "Intrinsic", "::", "memmove", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemmove", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "break", ";", "case", "Intrinsic", "::", "memset", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemset", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "Factor", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Expected a memcpy/move or memset!", "<STR_LIT>", ")", ";", "}", "std", "::", "vector", "<", "EVT", ">", "MemOps", ";", "if", "(", "getTLI", "(", ")", "->", "findOptimalMemOpLowering", "(", "MemOps", ",", "Limit", ",", "MOp", ",", "DstAddrSpace", ",", "SrcAddrSpace", ",", "F", "->", "getAttributes", "(", ")", ")", ")", "return", "MemOps", ".", "size", "(", ")", "*", "Factor", ";", "return", "-", "<NUM_LIT>" ]

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

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

[ "SImode", ",", "LP_REGNUM", ")", ")" ]

[ "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "gen_rtx_REG", "(" ]

[ "if", "(", "Op", ".", "getReg", "(", ")", ".", "isPhysical", "(", ")", "||", "(", "Op", ".", "isDef", "(", ")", "&&", "Op", ".", "getSubReg", "(", ")", "!=", "AMDGPU", "::", "NoSubRegister", ")", ")", "return", "false", ";" ]

[ "if", "(", "!", "SU", ".", "isInstr", "(", ")", ")", "return", "false", ";", "for", "(", "const", "auto", "&", "Op", ":", "SU", ".", "getInstr", "(", ")", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "continue", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_pfadd", "(", "_", "_", "m64", "_", "_", "A", ",", "_", "_", "m64", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pfadd", "(", "(", "_", "_", "v2sf", ")", "_", "_", "A", ",", "(" ]

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

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

[ "<STR_LIT>", ")" ]

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

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

[ "return", "(", "float32x4_t", ")", "_", "_", "builtin_aarch64_combinev2sf", "(", "_" ]

[ ",", "CPSR", ",", "(", "opnode", "GPR", ":", "$", "Rn", ",", "mod_imm", ":", "$", "imm", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteALU", ",", "ReadALU", "]", ">", ";" ]

[ "def", "ri", ":", "ARMPseudoInst", "<", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "mod_imm", ":", "$", "imm", ",", "pred", ":", "$", "p", ")", ",", "<NUM_LIT>", ",", "iii", ",", "[", "(", "set", "GPR", ":", "$", "Rd" ]

[ "}" ]

[ "int", "X86FrameLowering", "::", "getFrameIndexOffset", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ")", "const", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "<NUM_LIT>", ")", "{", "return", "Offset", "+", "RegInfo", "->", "getSlotSize", "(", ")", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", "->", "getObjectAlignment", "(", "FI", ")", "==", "<NUM_LIT>", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "{", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "return", "Offset", "+", "StackSize", ";", "Offset", "+=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "int", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "<NUM_LIT>", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "Offset", ";" ]

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

[ "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntr", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntrFP", "[", "]", "=", "{" ]

[ "bool", "SIAddIMGInit", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "RI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "auto", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "MI", ".", "mayStore", "(", ")", ")", "{", "MachineOperand", "*", "TFE", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "tfe", ")", ";", "MachineOperand", "*", "LWE", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "lwe", ")", ";", "MachineOperand", "*", "D16", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "d16", ")", ";", "assert", "(", "(", "TFE", "&&", "LWE", ")", "&&", "<STR_LIT>", "Expected tfe and lwe operands in instruction", "<STR_LIT>", ")", ";", "unsigned", "TFEVal", "=", "TFE", "->", "getImm", "(", ")", ";", "unsigned", "LWEVal", "=", "LWE", "->", "getImm", "(", ")", ";", "unsigned", "D16Val", "=", "D16", "?", "D16", "->", "getImm", "(", ")", ":", "<NUM_LIT>", ";", "if", "(", "TFEVal", "||", "LWEVal", ")", "{", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "DstIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "MachineOperand", "*", "MO_Dmask", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "dmask", ")", ";", "assert", "(", "MO_Dmask", "&&", "<STR_LIT>", "Expected dmask operand in instruction", "<STR_LIT>", ")", ";", "unsigned", "dmask", "=", "MO_Dmask", "->", "getImm", "(", ")", ";", "unsigned", "ActiveLanes", "=", "TII", "->", "isGather4", "(", "Opcode", ")", "?", "<NUM_LIT>", ":", "countPopulation", "(", "dmask", ")", ";", "static_assert", "(", "AMDGPU", "::", "sub0", "==", "<NUM_LIT>", "&&", "AMDGPU", "::", "sub4", "==", "<NUM_LIT>", ",", "<STR_LIT>", "Subreg indices different from expected", "<STR_LIT>", ")", ";", "bool", "Packed", "=", "!", "ST", ".", "hasUnpackedD16VMem", "(", ")", ";", "unsigned", "InitIdx", "=", "D16Val", "&&", "Packed", "?", "(", "(", "ActiveLanes", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ":", "ActiveLanes", "+", "<NUM_LIT>", ";", "uint32_t", "DstSize", "=", "RI", "->", "getRegSizeInBits", "(", "*", "TII", "->", "getOpRegClass", "(", "MI", ",", "DstIdx", ")", ")", "/", "<NUM_LIT>", ";", "if", "(", "DstSize", "<", "InitIdx", ")", "continue", ";", "Register", "PrevDst", "=", "MRI", ".", "createVirtualRegister", "(", "TII", "->", "getOpRegClass", "(", "MI", ",", "DstIdx", ")", ")", ";", "unsigned", "NewDst", "=", "<NUM_LIT>", ";", "unsigned", "SizeLeft", "=", "ST", ".", "usePRTStrictNull", "(", ")", "?", "InitIdx", ":", "<NUM_LIT>", ";", "unsigned", "CurrIdx", "=", "ST", ".", "usePRTStrictNull", "(", ")", "?", "<NUM_LIT>", ":", "InitIdx", ";", "if", "(", "DstSize", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "PrevDst", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "NewDst", "=", "PrevDst", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "PrevDst", ")", ";", "for", "(", ";", "SizeLeft", ";", "SizeLeft", "--", ",", "CurrIdx", "++", ")", "{", "NewDst", "=", "MRI", ".", "createVirtualRegister", "(", "TII", "->", "getOpRegClass", "(", "MI", ",", "DstIdx", ")", ")", ";", "Register", "SubReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "SubReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "INSERT_SUBREG", ")", ",", "NewDst", ")", ".", "addReg", "(", "PrevDst", ")", ".", "addReg", "(", "SubReg", ")", ".", "addImm", "(", "CurrIdx", ")", ";", "PrevDst", "=", "NewDst", ";", "}", "}", "MachineInstrBuilder", "(", "MF", ",", "MI", ")", ".", "addReg", "(", "NewDst", ",", "RegState", "::", "Implicit", ")", ";", "MI", ".", "tieOperands", "(", "DstIdx", ",", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "}", "return", "Changed", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "return", "ResultReg", ";" ]

[ "Align", "=", "TD", ".", "getTypeAllocSize", "(", "C", "->", "getType", "(", ")", ")", ";", "}", "unsigned", "PICBase", "=", "<NUM_LIT>", ";", "unsigned", "char", "OpFlag", "=", "<NUM_LIT>", ";", "if", "(", "Subtarget", "->", "isPICStyleStubPIC", "(", ")", ")", "{", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "PICBase", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "&", "MF", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "{", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "PICBase", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "&", "MF", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", "&&", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ")", "{", "PICBase", "=", "X86", "::", "RIP", ";", "}", "unsigned", "MCPOffset", "=", "MCP", ".", "getConstantPoolIndex", "(", "C", ",", "Align", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "addConstantPoolReference", "(", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ",", "MCPOffset", ",", "PICBase", ",", "OpFlag", ")", ";" ]

[ "if", "(", "RegsToUpdate", ".", "insert", "(", "Reg", ")", ".", "second", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Adding register: ", "<STR_LIT>", "<<", "Register", "::", "virtReg2Index", "(", "Reg", ")", "<<", "<STR_LIT>", " on line ", "<STR_LIT>", "<<", "Line", "<<", "<STR_LIT>", " for re-computation of kill flags\\n", "<STR_LIT>", ")", ";" ]

[ "void", "PPCMIPeephole", "::", "addRegToUpdateWithLine", "(", "Register", "Reg", ",", "int", "Line", ")", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "return", ";" ]

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

[ "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "<=", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno" ]

[ "}" ]

[ "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "<NUM_LIT>", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "<NUM_LIT>", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "<NUM_LIT>", ";", "}", "return", "{", "}", ";" ]

[ ":", "InstrItinClass", ";" ]

[ "def", "tc_49a8207d" ]

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

[ "def", "A2_tfrfnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_2op", ">", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "resetTargetOptions", "(", "F", ")", ";", "return", "getSubtargetImpl", "(", "CPU", ",", "FS", ")", ";", "}" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "<FIXS>", "rs6000_invalid_builtin", "(", "fcode", ")", ";", "<FIXE>" ]

[ "||", "(", "e", "==", "ENB_P10_64", "&&", "TARGET_POWER10", "&&", "TARGET_POWERPC64", ")", "||", "(", "e", "==", "ENB_MMA", "&&", "TARGET_MMA", ")", ")", ")", "{", "<BUGS>", "rs6000_invalid_new_builtin", "(", "fcode", ")", ";", "<BUGE>", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}" ]

[ ")", "]" ]

[ "[", "(", "match_operand", ":", "VNx16BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "and", ":", "VNx16BI", "(", "reg", ":", "VNx16BI", "FFRT_REGNUM", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_PTEST", ")", ")", "(", "clobber", "(", "match_scratch", ":", "VNx16BI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "emit_insn", "(", "gen_altivec_vmuloub", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "BYTES_BIG_ENDIAN", ")" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "==", "LO_SUM", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "DP_REGNO", ")", "<FIXE>" ]

[ "case", "'", "K", "'", ":", "if", "(", "!", "TARGET_SMALL", "&&", "code", "==", "MEM", "<BUGS>", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "DP_REGNO", ")", "<BUGE>", "{", "op1", "=", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "op1", ")", "==", "SYMBOL_REF", ")" ]

[ "->", "getValue", "(", ")", ";" ]

[ "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "MCExpr", "*", "IdVal", ";", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Dollar", ")", ")", "{", "return", "matchCPURegisterName", "(", "Parser", ".", "getLexer", "(", ")", ".", "peekTok", "(", ")", ".", "getString", "(", ")", ")", "==", "-", "<NUM_LIT>", "?", "MatchOperand_ParseFail", ":", "MatchOperand_NoMatch", ";", "}", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "IdVal", ")", ")", "return", "MatchOperand_ParseFail", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "IdVal", ")", ";", "if", "(", "!", "MCE", ")", "return", "MatchOperand_NoMatch", ";", "int64_t", "Val", "=", "MCE" ]

[ "let", "cofMax1", "=", "<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", "isIndirectBranch", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";" ]