Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "reg", ":", "ALL4A", "<NUM_LIT>", ")", "(", "usdiv", ":", "ALL4A", "(", "reg", ":", "ALL4A", "<NUM_LIT>", ")", "(", "reg", ":", "ALL4A", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "static", "unsigned", "long", "arm_compute_save_core_reg_mask", "(", "void", ")", "{", "unsigned", "int", "save_reg_mask", "=", "<NUM_LIT>", ";", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "unsigned", "int", "reg", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "PC_REGNUM", ")", ";", "save_reg_mask", "|=", "arm_compute_save_reg0_reg12_mask", "(", ")", ";", "if", "(", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", "||", "(", "save_reg_mask", "&&", "optimize_size", "&&", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_NORMAL", "&&", "!", "crtl", "->", "tail_call_emit", "&&", "!", "crtl", "->", "calls_eh_return", ")", ")", "save_reg_mask", "|=", "<NUM_LIT>", "<<", "LR_REGNUM", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "save_reg_mask", "&=", "~", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "(", "(", "bit_count", "(", "save_reg_mask", ")", "+", "ARM_NUM_INTS", "(", "crtl", "->", "args", ".", "pretend_args_size", "+", "arm_compute_static_chain_stack_bytes", "(", ")", ")", ")", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<=", "<NUM_LIT>", ";", "reg", "++", ")", "if", "(", "(", "save_reg_mask", "&", "(", "<NUM_LIT>", "<<", "reg", ")", ")", "==", "<NUM_LIT>", ")", "break", ";", "if", "(", "reg", "<=", "<NUM_LIT>", ")", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "reg", ")", ";", "else", "{", "cfun", "->", "machine", "->", "sibcall_blocked", "=", "<NUM_LIT>", ";", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "TARGET_THUMB2", "&&", "IS_NESTED", "(", "func_type", ")", "&&", "flag_pic", "&&", "(", "save_reg_mask", "&", "THUMB2_WORK_REGS", ")", "==", "<NUM_LIT>", ")", "{", "reg", "=", "thumb_find_work_register", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "reg", ")", ";", "}", "return", "save_reg_mask", ";", "}" ]

[ "Compute", "a", "bit", "mask", "of", "which", "core", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", ".", "This", "is", "used", "by", "arm_compute_frame_layout", ",", "which", "may", "add", "extra", "registers", "." ]

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

[ "int", "argspace_offset", "=", "crtl", "->", "outgoing_args_size", ";", "int", "pretend", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "rtx", "mem", ";", "bool", "return_address_on_stack", "=", "cris_return_address_on_stack", "(", ")", ";", "int", "n_movem_regs", "=", "<NUM_LIT>", ";", "if", "(", "!", "TARGET_PROLOGUE_EPILOGUE", ")", "return", ";", "if", "(", "TARGET_STACK_ALIGN", ")", "size", "=", "TARGET_ALIGN_BY_32", "?", "(", "size", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", ":", "(", "size", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", ";", "for", "(", "regno", "=", "<NUM_LIT>", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "cris_reg_saved_in_regsave_area", "(", "regno", ")", ")", "{", "n_movem_regs", "++", ";", "if", "(", "regno", "==", "last_movem_reg", "+", "<NUM_LIT>", ")", "last_movem_reg", "=", "regno", ";", "else", "break", ";", "}", "if", "(", "n_movem_regs", "==", "<NUM_LIT>", ")", "last_movem_reg", "=", "-", "<NUM_LIT>", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "<NUM_LIT>", ";", "regno", ">", "last_movem_reg", ";", "regno", "--", ")", "if", "(", "cris_reg_saved_in_regsave_area", "(", "regno", ")", ")", "{", "rtx", "insn", ";", "if", "(", "argspace_offset", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "GEN_INT", "(", "argspace_offset", ")", ")", ")", ";", "argspace_offset", "=", "<NUM_LIT>", ";", "}", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_raw_REG", "(", "SImode", ",", "regno", ")", ",", "mem", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "if", "(", "last_movem_reg", "!=", "-", "<NUM_LIT>", ")", "{", "rtx", "insn", ";", "if", "(", "argspace_offset", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "GEN_INT", "(", "argspace_offset", ")", ")", ")", ";", "argspace_offset", "=", "<NUM_LIT>", ";", "}", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "insn", "=", "emit_insn", "(", "cris_gen_movem_load", "(", "mem", ",", "GEN_INT", "(", "last_movem_reg", "+", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "side_effects_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "rtx", "insn", ";", "emit_insn", "(", "gen_cris_frame_deallocated_barrier", "(", ")", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "mem", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "else", "if", "(", "(", "size", "+", "argspace_offset", ")", "!=", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_cris_frame_deallocated_barrier", "(", ")", ")", ";", "size", "+=", "argspace_offset", ";", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "}", "if", "(", "return_address_on_stack", "&&", "pretend", "==", "<NUM_LIT>", ")", "{", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "rtx", "mem", ";", "rtx", "insn", ";", "rtx", "srpreg", "=", "gen_raw_REG", "(", "SImode", ",", "CRIS_SRP_REGNUM", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "srpreg", ",", "mem", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "gen_raw_REG", "(", "SImode", ",", "CRIS_STACKADJ_REG", ")", ")", ")", ";", "cris_expand_return", "(", "false", ")", ";", "}", "else", "cris_expand_return", "(", "true", ")", ";", "return", ";", "}", "if", "(", "pretend", "!=", "<NUM_LIT>", ")", "{", "if", "(", "return_address_on_stack", ")", "{", "rtx", "mem", ";", "rtx", "srpreg", "=", "gen_raw_REG", "(", "SImode", ",", "CRIS_SRP_REGNUM", ")", ";", "rtx", "insn", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_frame_alias_set", "(", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "srpreg", ",", "mem", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "GEN_INT", "(", "pretend", ")", ")", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "gen_raw_REG", "(", "SImode", ",", "CRIS_STACKADJ_REG" ]

[ ")", ";" ]

[ "SDValue", "V2", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Dl", ",", "VT", ",", "V", ")", ",", "<NUM_LIT>", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "V1", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "V2", ")", ";", "CurDAG", "->", "RemoveDeadNode", "(", "N" ]

[ "i32imm", ":", "$", "idx", ")", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd", "," ]

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

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

[ "const", "override", "{" ]

[ "const", "DataLayout", "*", "getDataLayout", "(", ")" ]

[ "g8rc_nox0", ":", "$", "F", ",", "i32imm", ":", "$", "BROPC", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";" ]

[ "def", "SELECT_CC_I8", ":", "PPCCustomInserterPseudo", "<", "(", "outs", "g8rc", ":", "$", "dst", ")", ",", "(", "ins", "crrc", ":", "$", "cond", ",", "g8rc_nox0", ":", "$", "T", "," ]

[ "N", "->", "getScale", "(", ")", ";" ]

[ "if", "(", "auto", "*", "N", "=", "dyn_cast", "<", "MaskedGatherScatterSDNode", ">", "(", "Op", ".", "getNode", "(", ")", ")", ")", "return" ]

[ "}" ]

[ "def", "A64FXWrite_ADDLV", ":", "SchedWriteRes", "<", "[", "A64FXGI03", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "case", "PSEUDO_PREG_SPILL", ":", "case", "PSEUDO_POSTLOOP_RELOAD", ":", "<FIXE>" ]

[ "switch", "(", "opc", ")", "{", "case", "LWS", ":", "case", "LHS", ":", "case", "LBS", ":", "case", "LHUS", ":", "case", "LBUS", ":", "case", "SWS", ":", "case", "SHS", ":", "case", "SBS", ":", "case", "PSEUDO_PREG_RELOAD", ":", "<BUGS>", "case", "PSEUDO_PREG_SPILL", ":", "<BUGE>", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "LWL", ":", "case", "LHL", ":", "case", "LBL", ":", "case", "LHUL", ":", "case", "LBUL", ":", "case", "SWL", ":", "case", "SHL", ":", "case", "SBL", ":" ]

[ "}" ]

[ "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_RegMask", ":", "CSR_Darwin64_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_RegMask", ":", "CSR_Darwin32_RegMask", ")", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "assert", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "<STR_LIT>", "Altivec is not implemented on AIX yet.", "<STR_LIT>", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "CSR_AIX64_RegMask", ":", "CSR_AIX32_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR32_ColdCC_SPE_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_RegMask", ":", "CSR_SVR464_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR432_SPE_RegMask", ":", "CSR_SVR432_RegMask", ")", ")", ";" ]

[ "<FIXS>", "return", "LowerFastCCCallTo", "(", "Op", ",", "DAG", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "return", "LowerCCCCallTo", "(", "Op", ",", "DAG", ",", "true", ")", ";", "<FIXE>" ]

[ "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unsupported calling convention", "<STR_LIT>", ")", ";", "case", "CallingConv", "::", "Fast", ":", "if", "(", "EnableFastCC", ")", "{", "<BUGS>", "return", "LowerFastCCCallTo", "(", "Op", ",", "DAG", ",", "false", ")", ";", "<BUGE>", "}", "case", "CallingConv", "::", "C", ":", "<BUGS>", "case", "CallingConv", "::", "CSRet", ":", "<BUGE>", "return", "LowerCCCCallTo", "(", "Op", ",", "DAG", ")", ";", "case", "CallingConv", "::", "X86_StdCall", ":", "<BUGS>", "return", "LowerStdCallCCCallTo", "(", "Op", ",", "DAG", ")", ";", "<BUGE>", "case", "CallingConv", "::", "X86_FastCall", ":", "return", "LowerFastCCCallTo", "(", "Op", ",", "DAG", ",", "true", ")", ";", "}" ]

[ "immediate", "<STR_LIT>", ")", ",", "Fixup", ",", "Ctx", ")", ";" ]

[ "unsigned_width", "(", "<NUM_LIT>", ",", "Value", ",", "std", "::", "string", "(", "<STR_LIT>" ]

[ ")", ";" ]

[ "NewMIs", ".", "push_back", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "PPC", "::", "RLWINM", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addImm", "(", "<NUM_LIT>", "-", "ShiftBits", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "}", "NewMIs", ".", "push_back", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "isPPC64", "(", ")", "?", "PPC", "::", "MTCRF8", ":", "PPC", "::", "MTCRF", ")", ",", "DestReg", ")", ".", "addReg", "(", "ScratchReg", ")", ")", ";", "}", "}", "else", "if", "(", "PPC", "::", "CRBITRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "unsigned", "Reg", "=", "<NUM_LIT>", ";", "if", "(", "DestReg", "==", "PPC", "::", "CR0LT", "||", "DestReg", "==", "PPC", "::", "CR0GT", "||", "DestReg", "==", "PPC", "::", "CR0EQ", "||", "DestReg", "==", "PPC", "::", "CR0UN", ")", "Reg", "=", "PPC", "::", "CR0", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR1LT", "||", "DestReg", "==", "PPC", "::", "CR1GT", "||", "DestReg", "==", "PPC", "::", "CR1EQ", "||", "DestReg", "==", "PPC", "::", "CR1UN", ")", "Reg", "=", "PPC", "::", "CR1", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR2LT", "||", "DestReg", "==", "PPC", "::", "CR2GT", "||", "DestReg", "==", "PPC", "::", "CR2EQ", "||", "DestReg", "==", "PPC", "::", "CR2UN", ")", "Reg", "=", "PPC", "::", "CR2", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR3LT", "||", "DestReg", "==", "PPC", "::", "CR3GT", "||", "DestReg", "==", "PPC", "::", "CR3EQ", "||", "DestReg", "==", "PPC", "::", "CR3UN", ")", "Reg", "=", "PPC", "::", "CR3", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR4LT", "||", "DestReg", "==", "PPC", "::", "CR4GT", "||", "DestReg", "==", "PPC", "::", "CR4EQ", "||", "DestReg", "==", "PPC", "::", "CR4UN", ")", "Reg", "=", "PPC", "::", "CR4", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR5LT", "||", "DestReg", "==", "PPC", "::", "CR5GT", "||", "DestReg", "==", "PPC", "::", "CR5EQ", "||", "DestReg", "==", "PPC", "::", "CR5UN", ")", "Reg", "=", "PPC", "::", "CR5", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR6LT", "||", "DestReg", "==", "PPC", "::", "CR6GT", "||", "DestReg", "==", "PPC", "::", "CR6EQ", "||", "DestReg", "==", "PPC", "::", "CR6UN", ")", "Reg", "=", "PPC", "::", "CR6", ";", "else", "if", "(", "DestReg", "==", "PPC", "::", "CR7LT", "||", "DestReg", "==", "PPC", "::", "CR7GT", "||", "DestReg", "==", "PPC", "::", "CR7EQ", "||", "DestReg", "==", "PPC", "::", "CR7UN", ")", "Reg", "=", "PPC", "::", "CR7", ";", "return", "LoadRegFromStackSlot", "(", "MF", ",", "DL", ",", "Reg", ",", "FrameIdx", ",", "&", "PPC", "::", "CRRCRegClass", ",", "NewMIs", ")", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "bool", "Is64Bit", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "isPPC64", "(" ]

[ "bool", "nds32_valid_multiple_load_store", "(", "rtx", "op", ",", "bool", "load_p", ")", "{", "int", "count", ";", "int", "first_elt_regno", ";", "rtx", "elt", ";", "count", "=", "XVECLEN", "(", "op", ",", "<NUM_LIT>", ")", ";", "elt", "=", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", "||", "count", "<=", "<NUM_LIT>", "||", "count", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "load_p", ")", "{", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "elt", ")", ")", "!=", "REG", "||", "GET_CODE", "(", "SET_SRC", "(", "elt", ")", ")", "!=", "MEM", ")", "return", "false", ";", "first_elt_regno", "=", "REGNO", "(", "SET_DEST", "(", "elt", ")", ")", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "elt", ")", ")", "!=", "REG", "||", "GET_CODE", "(", "SET_DEST", "(", "elt", ")", ")", "!=", "MEM", ")", "return", "false", ";", "first_elt_regno", "=", "REGNO", "(", "SET_SRC", "(", "elt", ")", ")", ";", "}", "if", "(", "!", "nds32_consecutive_registers_load_store_p", "(", "op", ",", "load_p", ",", "<NUM_LIT>", ",", "first_elt_regno", ",", "count", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Function", "to", "check", "whether", "the", "OP", "is", "a", "valid", "load/store", "operation", ".", "This", "is", "a", "helper", "function", "for", "the", "predicates", ":", "'nds32_load_multiple_operation", "'", "and", "'nds32_store_multiple_operation", "'", "in", "predicates.md", "file", ".", "The", "OP", "is", "supposed", "to", "be", "a", "parallel", "rtx", ".", "For", "each", "element", "within", "this", "parallel", "rtx", ":", "(", "set", "(", "reg", ")", "(", "mem", "addr", ")", ")", "is", "the", "form", "for", "load", "operation", ".", "(", "set", "(", "mem", "addr", ")", "(", "reg", ")", ")", "is", "the", "form", "for", "store", "operation", ".", "We", "have", "to", "extract", "reg", "and", "mem", "of", "every", "element", "and", "check", "if", "the", "information", "is", "valid", "for", "multiple", "load/store", "operation", "." ]

[ "void", "crx_expand_epilogue", "(", "void", ")", "{", "rtx", "return_reg", ";", "int", "only_popret_RA", "=", "(", "save_regs", "[", "RETURN_ADDRESS_REGNUM", "]", "&&", "(", "sum_regs", "==", "UNITS_PER_WORD", ")", ")", ";", "return_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDRESS_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_move_insn", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ";", "if", "(", "size_for_adjusting_sp", ">", "<NUM_LIT>", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size_for_adjusting_sp", ")", ")", ")", ";", "if", "(", "crx_interrupt_function_p", "(", ")", ")", "emit_jump_insn", "(", "gen_interrupt_return", "(", ")", ")", ";", "else", "if", "(", "last_reg_to_save", "==", "-", "<NUM_LIT>", ")", "emit_jump_insn", "(", "gen_indirect_jump_return", "(", ")", ")", ";", "else", "if", "(", "only_popret_RA", ")", "emit_jump_insn", "(", "gen_popret_RA_return", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_pop_and_popret_return", "(", "GEN_INT", "(", "sum_regs", ")", ")", ")", ";", "}" ]

[ "Generate", "insn", "that", "updates", "the", "stack", "for", "local", "variables", "and", "padding", "for", "*", "registers", "we", "save", ".", "-", "Generate", "the", "appropriate", "return", "insn", "." ]

[ "stack_pointer_rtx", ")", ",", "reg", ")", ";" ]

[ "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "<NUM_LIT>", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "<NUM_LIT>", ";", "XVECEXP", "(", "par", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "<NUM_LIT>", ")", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "<NUM_LIT>", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "<NUM_LIT>", ";", "XVECEXP", "(", "dwarf", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "tmp", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "DFmode", "," ]

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

[ "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "ST_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "<NUM_LIT>", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "ST_REGS", "]", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "FP_REG_FIRST", "," ]

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

[ "static", "bool", "m32r_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "m32r_rtx_ok_for_base_p", "(", "x", ",", "strict", ")", "||", "m32r_legitimate_offset_addres_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_legitimate_lo_sum_addres_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_load_postinc_p", "(", "mode", ",", "x", ",", "strict", ")", "||", "m32r_store_preinc_predec_p", "(", "mode", ",", "x", ",", "strict", ")", ")", "return", "true", ";" ]

[ "<FIXS>", "rtx", "perm_rtx", "[", "<NUM_LIT>", "]", "<FIXE>" ]

[ "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", "char", "*", "perm", "<BUGS>", "rtx", "perm_rtx", "[", "<NUM_LIT>", "]", ",", "constv", "<BUGE>", "switch", "(", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "MODE", ">", "mode", ")", ")", ")", "{" ]

[ "return", "(", "Pred", "!=", "EXECZ", "&&", "Pred", "!=", "EXECNZ", ")", ";" ]

[ "}", "++", "I", ";", "}", "if", "(", "I", "==", "E", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "MaskBrDest", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "TBB", "!=", "MaskBrDest", "||", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "Pred", "=", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ";" ]

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

[ "bit", "InstImage", "=", "<NUM_LIT>", ";", "bit", "InstLane", "=", "<NUM_LIT>", ";", "bit", "InstMem", "=", "<NUM_LIT>", ";", "bit", "InstMemFence", "=", "<NUM_LIT>", ";", "bit", "InstMod", "=", "<NUM_LIT>", ";", "bit", "InstQueryImage", "=", "<NUM_LIT>", ";", "bit", "InstQuerySampler", "=", "<NUM_LIT>", ";", "bit", "InstQueue", "=", "<NUM_LIT>", ";", "bit", "InstSeg", "=", "<NUM_LIT>", ";", "bit", "InstSegCvt", "=", "<NUM_LIT>", ";", "bit", "InstSignal", "=", "<NUM_LIT>", ";", "bit", "InstSourceType", "=", "<NUM_LIT>", ";", "bit", "isConv", "=", "<NUM_LIT>", ";", "bit", "isImageInst", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "RoundAttr", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "WidthAttr", "=", "WidthAttrValues", ".", "ONE", ";", "bit", "HasDefaultSegment", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstAddr", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstAtomic", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstBasic", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstBr", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstCmp", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstCvt", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstImage", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstLane", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstMem", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstMemFence", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstMod", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstQueryImage", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstQuerySampler", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstQueue", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstSeg", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstSegCvt", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstSignal", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "InstSourceType", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "isConv", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "isImageInst", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RoundAttr", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-" ]

[ "void", "sh_function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "ca", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "if", "(", "ca", "->", "force_mem", ")", "ca", "->", "force_mem", "=", "<NUM_LIT>", ";", "else", "if", "(", "TARGET_SH5", ")", "{", "tree", "type2", "=", "(", "ca", "->", "byref", "&&", "type", "?", "TREE_TYPE", "(", "type", ")", ":", "type", ")", ";", "enum", "machine_mode", "mode2", "=", "(", "ca", "->", "byref", "&&", "type", "?", "TYPE_MODE", "(", "type2", ")", ":", "mode", ")", ";", "int", "dwords", "=", "(", "(", "ca", "->", "byref", "?", "ca", "->", "byref", ":", "mode2", "==", "BLKmode", "?", "int_size_in_bytes", "(", "type2", ")", ":", "GET_MODE_SIZE", "(", "mode2", ")", ")", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "int", "numregs", "=", "MIN", "(", "dwords", ",", "NPARM_REGS", "(", "SImode", ")", "-", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", ")", ";", "if", "(", "numregs", ")", "{", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "+=", "numregs", ";", "if", "(", "TARGET_SHCOMPACT", "&&", "SHCOMPACT_FORCE_ON_STACK", "(", "mode2", ",", "type2", ")", ")", "{", "ca", "->", "call_cookie", "|=", "CALL_COOKIE_INT_REG", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "-", "numregs", ",", "<NUM_LIT>", ")", ";", "ca", "->", "stack_regs", "+=", "numregs", ";", "}", "else", "if", "(", "ca", "->", "byref", ")", "{", "if", "(", "!", "ca", "->", "outgoing", ")", "ca", "->", "stack_regs", "+=", "numregs", ";", "ca", "->", "byref_regs", "+=", "numregs", ";", "ca", "->", "byref", "=", "<NUM_LIT>", ";", "do", "ca", "->", "call_cookie", "|=", "CALL_COOKIE_INT_REG", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "-", "numregs", ",", "<NUM_LIT>", ")", ";", "while", "(", "--", "numregs", ")", ";", "ca", "->", "call_cookie", "|=", "CALL_COOKIE_INT_REG", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "dwords", ">", "numregs", ")", "{", "int", "pushregs", "=", "numregs", ";", "if", "(", "TARGET_SHCOMPACT", ")", "ca", "->", "stack_regs", "+=", "numregs", ";", "while", "(", "pushregs", "<", "NPARM_REGS", "(", "SImode", ")", "-", "<NUM_LIT>", "&&", "(", "CALL_COOKIE_INT_REG_GET", "(", "ca", "->", "call_cookie", ",", "NPARM_REGS", "(", "SImode", ")", "-", "pushregs", ")", "==", "<NUM_LIT>", ")", ")", "{", "ca", "->", "call_cookie", "&=", "~", "CALL_COOKIE_INT_REG", "(", "NPARM_REGS", "(", "SImode", ")", "-", "pushregs", ",", "<NUM_LIT>", ")", ";", "pushregs", "++", ";", "}", "if", "(", "numregs", "==", "NPARM_REGS", "(", "SImode", ")", ")", "ca", "->", "call_cookie", "|=", "CALL_COOKIE_INT_REG", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "|", "CALL_COOKIE_STACKSEQ", "(", "numregs", "-", "<NUM_LIT>", ")", ";", "else", "ca", "->", "call_cookie", "|=", "CALL_COOKIE_STACKSEQ", "(", "numregs", ")", ";", "}", "}", "if", "(", "GET_SH_ARG_CLASS", "(", "mode2", ")", "==", "SH_ARG_FLOAT", "&&", "(", "named", "||", "!", "ca", "->", "prototype_p", ")", ")", "{", "if", "(", "mode2", "==", "SFmode", "&&", "ca", "->", "free_single_fp_reg", ")", "ca", "->", "free_single_fp_reg", "=", "<NUM_LIT>", ";", "else", "if", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "<", "NPARM_REGS", "(", "SFmode", ")", ")", "{", "int", "numfpregs", "=", "MIN", "(", "(", "GET_MODE_SIZE", "(", "mode2", ")", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", "*", "<NUM_LIT>", ",", "NPARM_REGS", "(", "SFmode", ")", "-", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", ")", ";", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "+=", "numfpregs", ";", "if", "(", "TARGET_SHCOMPACT", "&&", "!", "ca", "->", "prototype_p", ")", "{", "if", "(", "ca", "->", "outgoing", "&&", "numregs", ">", "<NUM_LIT>", ")", "do", "{", "ca", "->", "call_cookie", "|=", "(", "CALL_COOKIE_INT_REG", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "-", "numregs", "+", "(", "(", "numfpregs", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ")", ",", "<NUM_LIT>", "+", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "-", "numfpregs", ")", "/", "<NUM_LIT>", ")", ")", ";", "}", "while", "(", "numfpregs", "-=", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "mode2", "==", "SFmode", "&&", "(", "named", ")", "&&", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "<", "NPARM_REGS", "(", "SFmode", ")", ")", ")", "ca", "->", "free_single_fp_reg", "=", "FIRST_FP_PARM_REG", "-", "numfpregs", "+", "ca", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "+", "<NUM_LIT>", ";", "}", "}", "return", ";", "}", "if", "(", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", "&&", "TARGET_FPU_DOUBLE", ")", "{", "if", "(", "mode", "==", "SFmode", "&&", "ca", "->", "free_single_fp_reg", ")", "{", "ca", "->", "free_single_fp_reg", "=", "<NUM_LIT>", ";", "return", ";", "}", "if", "(", "mode", "==", "DFmode", "&&", "ROUND_REG", "(", "*", "ca", ",", "DFmode", ")", "!=", "ROUND_REG", "(", "*", "ca", ",", "SFmode", ")", ")", "{", "ca", "->", "free_single_fp_reg", "=", "(", "ROUND_REG", "(", "*", "ca", ",", "SFmode", ")", "+", "BASE_ARG_REG", "(", "mode", ")", ")", ";", "}", "}", "if", "(", "!", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A", ")", "||", "ca", "->", "renesas_abi", ")", "||", "PASS_IN_REG_P", "(", "*", "ca", ",", "mode", ",", "type", ")", ")", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "GET_SH_ARG_CLASS", "(", "mode", ")", "]", "=", "(", "ROUND_REG", "(", "*", "ca", ",", "mode", ")", "+", "(", "mode", "==", "BLKmode", "?", "ROUND_ADVANCE", "(", "int_size_in_bytes", "(", "type", ")", ")", ":", "ROUND_ADVANCE", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ")", ";", "}" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "}" ]

[ "const", "_", "_", "v16qu", "_", "_", "Q", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "_", "_", "v8hi", "_", "_", "C", "=", "(", "_", "_", "v8hi", ")", "(", "_", "_", "v2du", ")", "{", "_", "_", "A", ",", "_", "_", "B", "}", ";", "_", "_", "v8hi", "_", "_", "D", "=", "vec_perm", "(", "_", "_", "C", ",", "_", "_", "C", ",", "_", "_", "Q", ")", ";", "_", "_", "C", "=", "vec_perm", "(", "_", "_", "C", ",", "_", "_", "C", ",", "_", "_", "P", ")", ";", "_", "_", "C", "=", "vec_sub", "(", "_", "_", "C", ",", "_", "_", "D", ")", ";", "return", "(", "_", "_", "m64", ")", "(", "(", "_", "_", "v2du", ")", "_", "_", "C", ")", "[", "<NUM_LIT>", "]", ";" ]

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

[ "(", "and", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ior", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "]", ")" ]

[ "[", "(", "UNSPECV_BLOCKAGE", "\t", "\t", "<NUM_LIT>", ")", "(", "UNSPECV_FLUSH_ICACHE", "\t", "<NUM_LIT>", ")" ]

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

[ "def", "SKXWriteResGroup191", ":", "SchedWriteRes", "<", "[", "SKXPort0", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>" ]

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

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

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

[ "}" ]

[ "void", "forwardITPosition", "(", ")", "{", "if", "(", "!", "inITBlock", "(", ")", ")", "return", ";", "unsigned", "TZ", "=", "countTrailingZeros", "(", "ITState", ".", "Mask", ")", ";", "if", "(", "++", "ITState", ".", "CurPosition", "==", "<NUM_LIT>", "-", "TZ", ")", "ITState", ".", "CurPosition", "=", "~", "<NUM_LIT>", "U", ";" ]

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

[ "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "pattern_is_rotate64", "(", "body", ")", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "!=", "PARALLEL", ")", "return", "<NUM_LIT>", ";", "rtx", "set", "=", "XVECEXP", "(", "body" ]

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

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

[ "<FIXS>", "return", "VNx2DImode", ";", "<FIXE>" ]

[ "return", "VNx4SFmode", ";", "case", "E_HFmode", ":", "return", "VNx8HFmode", ";", "case", "E_DImode", ":", "<BUGS>", "return", "VNx2DImode", ";", "<BUGE>", "case", "E_SImode", ":", "return", "VNx4SImode", ";", "case", "E_HImode", ":" ]

[ "emit_insn", "(", "gen_atomic_compare_and_swap_1", "(", "mode", ",", "cond", ",", "wdst", ",", "mem", ",", "oldval", ",", "new", "val", ",", "align", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";" ]

[ "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "oldval", "=", "convert_modes", "(", "DImode", ",", "mode", ",", "oldval", ",", "<NUM_LIT>", ")", ";", "if", "(", "new", "val", "!=", "const0_rtx", ")", "new", "val", "=", "emit_insxl", "(", "mode", ",", "new", "val", ",", "addr", ")", ";", "wdst", "=", "gen_reg_rtx", "(", "DImode", ")", ";" ]

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

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

[ "assert", "(", "TiedOp", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Inactive register in vpred_r is not tied to an output!", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "addVPTPredNOperands", "(", "Inst", ",", "N", "-", "<NUM_LIT>", ")", ";", "unsigned", "RegNum", ";", "if", "(", "getVPTPred", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "RegNum", "=", "<NUM_LIT>", ";", "}", "else", "{", "unsigned", "NextOpIndex", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "ARMInsts", "[", "Inst", ".", "getOpcode", "(", ")", "]", ";", "int", "TiedOp", "=", "MCID", ".", "getOperandConstraint", "(", "NextOpIndex", ",", "MCOI", "::", "TIED_TO", ")", ";" ]

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

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

[ "}" ]

[ "vmlsq_lane_f32", "(", "float32x4_t", "_", "_", "a", ",", "float32x4_t", "_", "_", "b", ",", "float32x2_t", "_", "_", "c", ",", "const", "int", "_", "_", "d", ")", "{", "return", "(", "float32x4_t", ")", "_", "_", "builtin_neon_vmls_lanev4sf", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ",", "_", "_", "d", ")", ";" ]

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createMipsEmitGPRestorePass", "(", "MipsTargetMachine", "&", "tm", ")", "{", "return", "new", "Inserter", "(", "tm", ")", ";" ]

[ "MachineBasicBlock", "*", "BPFTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "ThisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "Copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "Copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy1MBB", ")", ";", "Copy1MBB", "->", "splice", "(", "Copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "Copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "unsigned", "LHS", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "RHS", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int", "CC", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "ISD", "::", "SETGT", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "case", "ISD", "::", "SETUGT", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "case", "ISD", "::", "SETGE", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "case", "ISD", "::", "SETEQ", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "case", "ISD", "::", "SETNE", ":", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "Copy1MBB", ")", ";", "break", ";", "default", ":", "report_fatal_error", "(", "<STR_LIT>", "unimplemented select CondCode ", "<STR_LIT>", "+", "Twine", "(", "CC", ")", ")", ";", "}", "BB", "=", "Copy0MBB", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "BB", "=", "Copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "Copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "ThisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "return", "DAG", ".", "getBuildVector", "(", "VT", ",", "DL", ",", "Args", ")", ";" ]

[ "EVT", "ExtraVT", "=", "cast", "<", "VTSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getVT", "(", ")", ";", "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "MVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "assert", "(", "VT", ".", "isVector", "(", ")", ")", ";", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "unsigned", "NElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Args", ";", "DAG", ".", "ExtractVectorElements", "(", "Src", ",", "Args", ",", "<NUM_LIT>", ",", "NElts", ")", ";", "SDValue", "VTOp", "=", "DAG", ".", "getValueType", "(", "ExtraVT", ".", "getScalarType", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "NElts", ";", "++", "I", ")", "Args", "[", "I", "]", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "DL", ",", "ScalarVT", ",", "Args", "[", "I", "]", ",", "VTOp", ")", ";" ]

[ "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";" ]

[ "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sdata", "<STR_LIT>", ",", "ELF", "::" ]

[ "buildMI", "(", "MBB", ",", "MBBI", ",", "StoreOpcode", ")", ".", "add", "(", "Op2", ")", ".", "add", "(", "Op1", ")", ";" ]

[ "unsigned", "LoadOpcode", "=", "(", "Width", "==", "<NUM_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "StoreOpcode", "=", "(", "Width", "==", "<NUM_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "buildMI", "(", "MBB", ",", "MBBI", ",", "LoadOpcode", ")", ".", "add", "(", "Op1", ")", ".", "add", "(", "Op2", ")", ";", "buildMI", "(", "MBB", ",", "MBBI", ",", "ArithOpcode", ")", ".", "add", "(", "Op1", ")", ".", "add", "(", "Op1", ")", ".", "add", "(", "Op2", ")", ";" ]

[ "}" ]

[ "MBBMRT", "*", "getMBBMRT", "(", ")", "override", "{", "return", "this", ";" ]

[ "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";" ]

[ "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{" ]

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

[ "def", ":", "InstRW", "<", "[", "WriteAdr", ",", "A64FXWrite_STP01", "]", ",", "(", "instrs", "STRSpre", ",", "STRSpost" ]

[ "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

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

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

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

[ "void", "tilepro_expand_movmisalign", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "<NUM_LIT>", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "tilepro_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "<NUM_LIT>", ",", "true", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "<NUM_LIT>", "]", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "tilepro_expand_unaligned_store", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "<NUM_LIT>", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}" ]

[ "Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "." ]

[ "Addr", ";" ]

[ "R2", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "Addr", ")", ",", "MVT", "::", "i32", ")", ";", "}", "else", "{", "R1", "=", "Addr", ";", "R2", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "Addr", ")", ",", "MVT", "::", "i32", ")", ";", "}", "}", "else", "if", "(", "Addr", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "R1", "=", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "R2", "=", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "R1", "=" ]

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

[ "if", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "CondTuple", "=", "std", "::", "make_tuple", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ",", "(", "bool", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "else", "if", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "CondTuple", "=", "std", "::", "make_tuple", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ",", "(", "bool", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ",", "(", "bool", ")", "Copy", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "unsigned", "CPClass", "=", "CCPair2CPClass", ".", "at", "(", "CondTuple", ")", ";", "unsigned", "SwappedClass", "=", "swapCPClass", "(", "CPClass", ")", ";", "CondTuple", "=", "CPClass2CCPairs", ".", "at", "(", "SwappedClass", ")", ".", "at", "(", "<NUM_LIT>", ")", ";", "if", "(", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "CondTuple", ")", "!=", "<STR_LIT>", "::" ]

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

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

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

[ "}", "else", "{", "unsigned", "NewOpc", "=", "(", "isLd", ")", "?", "(", "isT2", "?", "(", "OffImm", "<", "<NUM_LIT>", "?", "ARM", "::", "t2LDRi8", ":", "ARM", "::", "t2LDRi12", ")", ":", "ARM", "::", "LDRi12", ")", ":", "(", "isT2", "?", "(", "OffImm", "<", "<NUM_LIT>", "?", "ARM", "::", "t2STRi8", ":", "ARM", "::", "t2STRi12", ")", ":", "ARM", "::", "STRi12", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isLd", "&&", "(", "BaseKill", "||", "OffKill", ")", "&&", "(", "TRI", "->", "regsOverlap", "(", "EvenReg", ",", "BaseReg", ")", ")", ")", "{", "assert", "(", "!", "TRI", "->", "regsOverlap", "(", "OddReg", ",", "BaseReg", ")", ")", ";", "InsertLDR_STR", "(", "MBB", ",", "MBBI", ",", "OffImm", "+", "<NUM_LIT>", ",", "isLd", ",", "dl", ",", "NewOpc", ",", "OddReg", ",", "OddDeadKill", ",", "false", ",", "BaseReg", ",", "false", ",", "BaseUndef", ",", "false", ",", "OffUndef", ",", "Pred", ",", "PredReg", ",", "TII", ",", "isT2", ")", ";", "NewBBI", "=", "llvm", "::", "prior", "(", "MBBI", ")", ";", "InsertLDR_STR", "(", "MBB", ",", "MBBI", ",", "OffImm", ",", "isLd", ",", "dl", ",", "NewOpc", ",", "EvenReg", ",", "EvenDeadKill", ",", "false", ",", "BaseReg", ",", "BaseKill", ",", "BaseUndef", ",", "OffKill", ",", "OffUndef", ",", "Pred", ",", "PredReg", ",", "TII", ",", "isT2", ")", ";", "}", "else", "{", "if", "(", "OddReg", "==", "EvenReg", "&&", "EvenDeadKill", ")", "{", "EvenDeadKill", "=", "false", ";", "OddDeadKill", "=", "true", ";", "}", "InsertLDR_STR", "(", "MBB", ",", "MBBI", ",", "OffImm", ",", "isLd", ",", "dl", ",", "NewOpc", ",", "EvenReg", ",", "EvenDeadKill", ",", "EvenUndef", ",", "BaseReg", ",", "false", ",", "BaseUndef", ",", "false", ",", "OffUndef", ",", "Pred", ",", "PredReg", ",", "TII", ",", "isT2", ")", ";", "NewBBI", "=", "llvm", "::", "prior", "(", "MBBI", ")", ";", "InsertLDR_STR", "(", "MBB", ",", "MBBI", ",", "OffImm", "+", "<NUM_LIT>", ",", "isLd", ",", "dl", ",", "NewOpc", ",", "OddReg", ",", "OddDeadKill", ",", "OddUndef", ",", "BaseReg", ",", "BaseKill", ",", "BaseUndef", ",", "OffKill", ",", "OffUndef", ",", "Pred", ",", "PredReg", ",", "TII", ",", "isT2", ")", ";", "}", "if", "(", "isLd", ")", "++", "NumLDRD2LDR", ";", "else", "++", "NumSTRD2STR", ";", "}", "MBB", ".", "erase", "(" ]

[ "}" ]

[ "BitVector", "NewDefs", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ",", "NewUses", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ";", "bool", "HasHazard", "=", "false", ";", "for", "(", "unsigned", "I", "=", "Begin", ";", "I", "!=", "End", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", ")", "{", "if", "(", "checkRegDefsUses", "(", "NewDefs", ",", "NewUses", ",", "MO", ".", "getReg", "(", ")", ",", "MO", ".", "isDef", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_TYPE", "<STR_LIT>", ": found register hazard for operand ", "<STR_LIT>", "<<", "I", "<<", "<STR_LIT>", ": ", "<STR_LIT>", ";", "MO", ".", "dump", "(", ")", ")", ";", "HasHazard", "=", "true", ";", "}" ]

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

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

[ "}" ]

[ "case", "Intrinsic", "::", "umul_with_overflow", ":", "Opcode", "=", "ISD", "::", "UMULO", ";", "break", ";", "case", "Intrinsic", "::", "smul_with_overflow", ":", "Opcode", "=", "ISD", "::", "SMULO", ";", "break", ";", "}", "}", "LibFunc", "Func", ";", "if", "(", "!", "F", "->", "hasLocalLinkage", "(", ")", "&&", "F", "->", "hasName", "(", ")", "&&", "LibInfo", "&&", "LibInfo", "->", "getLibFunc", "(", "F", "->", "getName", "(", ")", ",", "Func", ")", "&&", "LibInfo", "->", "hasOptimizedCodeGen", "(", "Func", ")", ")", "{", "if", "(", "!", "CI", "->", "onlyReadsMemory", "(", ")", ")", "return", "true", ";", "if", "(", "!", "CI", "->", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", "->", "isFloatingPointTy", "(", ")", ")", "return", "true", ";", "switch", "(", "Func", ")", "{", "default", ":", "return", "true", ";", "case", "LibFunc_copysign", ":", "case", "LibFunc_copysignf", ":", "continue", ";", "case", "LibFunc_copysignl", ":", "return", "true", ";", "case", "LibFunc_fabs", ":", "case", "LibFunc_fabsf", ":", "case", "LibFunc_fabsl", ":", "continue", ";", "case", "LibFunc_sqrt", ":", "case", "LibFunc_sqrtf", ":", "case", "LibFunc_sqrtl", ":", "Opcode", "=", "ISD", "::", "FSQRT", ";", "break", ";", "case", "LibFunc_floor", ":", "case", "LibFunc_floorf", ":", "case", "LibFunc_floorl", ":", "Opcode", "=", "ISD", "::", "FFLOOR", ";", "break", ";", "case", "LibFunc_nearbyint", ":", "case", "LibFunc_nearbyintf", ":", "case", "LibFunc_nearbyintl", ":", "Opcode", "=", "ISD", "::", "FNEARBYINT", ";", "break", ";", "case", "LibFunc_ceil", ":", "case", "LibFunc_ceilf", ":", "case", "LibFunc_ceill", ":", "Opcode", "=", "ISD", "::", "FCEIL", ";", "break", ";", "case", "LibFunc_rint", ":", "case", "LibFunc_rintf", ":", "case", "LibFunc_rintl", ":", "Opcode", "=", "ISD", "::", "FRINT", ";", "break", ";", "case", "LibFunc_round", ":", "case", "LibFunc_roundf", ":", "case", "LibFunc_roundl", ":", "Opcode", "=", "ISD", "::", "FROUND", ";", "break", ";", "case", "LibFunc_trunc", ":", "case", "LibFunc_truncf", ":", "case", "LibFunc_truncl", ":", "Opcode", "=", "ISD", "::", "FTRUNC", ";", "break", ";", "case", "LibFunc_fmin", ":", "case", "LibFunc_fminf", ":", "case", "LibFunc_fminl", ":", "Opcode", "=", "ISD", "::", "FMINNUM", ";", "break", ";", "case", "LibFunc_fmax", ":", "case", "LibFunc_fmaxf", ":", "case", "LibFunc_fmaxl", ":", "Opcode", "=", "ISD", "::", "FMAXNUM", ";", "break", ";", "}", "}", "if", "(", "Opcode", ")", "{", "EVT", "EVTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "CI", "->", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "EVTy", "==", "MVT", "::", "Other", ")", "return", "true", ";", "if", "(", "TLI", "->", "isOperationLegalOrCustom", "(", "Opcode", ",", "EVTy", ")", ")", "continue", ";", "else", "if", "(", "EVTy", ".", "isVector", "(", ")", "&&", "TLI", "->", "isOperationLegalOrCustom", "(", "Opcode", ",", "EVTy", ".", "getScalarType", "(", ")", ")", ")", "continue", ";", "return", "true", ";", "}", "}", "return", "true", ";", "}", "else", "if", "(", "isa", "<", "BinaryOperator", ">", "(", "J", ")", "&&", "(", "J", "->", "getType", "(", ")", "->", "getScalarType", "(", ")", "->", "isFP128Ty", "(", ")", "||", "J", "->", "getType", "(", ")", "->", "getScalarType", "(", ")", "->", "isPPC_FP128Ty", "(", ")", ")", ")", "{", "return", "true", ";", "}", "else", "if", "(", "isa", "<", "UIToFPInst", ">", "(", "J", ")", "||", "isa", "<", "SIToFPInst", ">", "(", "J", ")", "||", "isa", "<", "FPToUIInst", ">", "(", "J", ")", "||", "isa", "<", "FPToSIInst", ">", "(", "J", ")", ")", "{", "CastInst", "*", "CI", "=", "cast", "<", "CastInst", ">", "(", "J", ")", ";", "if", "(", "CI", "->", "getSrcTy", "(", ")", "->", "getScalarType", "(", ")", "->", "isPPC_FP128Ty", "(", ")", "||", "CI", "->", "getDestTy", "(", ")", "->", "getScalarType", "(", ")", "->", "isPPC_FP128Ty", "(", ")", "||", "isLargeIntegerTy", "(", "!", "TM", ".", "isPPC64", "(", ")", ",", "CI", "->", "getSrcTy", "(", ")", "->", "getScalarType", "(", ")", ")", "||", "isLargeIntegerTy", "(", "!", "TM", ".", "isPPC64", "(", ")", ",", "CI", "->", "getDestTy", "(", ")", "->", "getScalarType", "(", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "isLargeIntegerTy", "(", "!", "TM", ".", "isPPC64", "(", ")", ",", "J", "->", "getType", "(", ")", "->", "getScalarType", "(", ")", ")", "&&", "(", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "UDiv", "||", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "SDiv", "||", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "URem", "||", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "SRem", ")", ")", "{", "return", "true", ";", "}", "else", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "&&", "isLargeIntegerTy", "(", "false", ",", "J", "->", "getType", "(", ")", "->", "getScalarType", "(", ")", ")", "&&", "(", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", "||", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", "||", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "LShr", ")", ")", "{", "return", "true", ";", "}", "else", "if", "(", "isa", "<", "IndirectBrInst", ">", "(", "J", ")", "||", "isa", "<", "InvokeInst", ">", "(", "J", ")", ")", "{", "return", "true", ";", "}", "else", "if", "(", "SwitchInst", "*", "SI", "=", "dyn_cast", "<", "SwitchInst", ">", "(", "J", ")", ")", "{", "if", "(", "SI", "->", "getNumCases", "(", ")", "+", "<NUM_LIT>", ">=", "(", "unsigned", ")", "TLI", "->", "getMinimumJumpTableEntries", "(", ")", ")", "return", "true", ";", "}", "if", "(", "J", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FRem", ")", "return", "true", ";", "if", "(", "ST", "->", "useSoftFloat", "(", ")", ")", "{", "switch", "(", "J", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "FAdd", ":", "case", "Instruction", "::", "FSub", ":", "case", "Instruction", "::", "FMul", ":", "case", "Instruction", "::", "FDiv", ":", "case", "Instruction", "::", "FPTrunc", ":", "case", "Instruction", "::", "FPExt", ":", "case", "Instruction", "::", "FPToUI", ":", "case", "Instruction", "::", "FPToSI", ":", "case", "Instruction", "::", "UIToFP", ":", "case", "Instruction", "::", "SIToFP", ":", "case", "Instruction", "::", "FCmp", ":", "return", "true", ";", "}" ]

[ "<NUM_LIT>", ";" ]

[ "def", "_2D", ":", "N2VCvt_Fx", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "VPR128", ",", "v2i64", ",", "v2f64", ",", "shr_imm64", ",", "IntOp", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "(", "plus", ":", "VDQ_BHSI", "(", "abs", ":", "VDQ_BHSI", "(", "minus", ":", "VDQ_BHSI" ]

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

[ "<FIXS>", "VEX", ",", "VVVV", ",", "WIG", ";", "<FIXE>", "<FIXS>", "VEX", ",", "VVVV", ",", "WIG", ";", "<FIXE>", "<FIXS>", "VEX", ",", "VVVV", ",", "VEX_L", ",", "WIG", ";", "<FIXE>", "<FIXS>", "VEX", ",", "VVVV", ",", "VEX_L", ",", "WIG", ";", "<FIXE>" ]

[ "let", "Predicates", "=", "[", "HasAVX", ",", "NoVLX", "]", "indefm", "VPMULLD", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "mul", ",", "v4i32", ",", "VR128", ",", "load", ",", "i128mem", ",", "SchedWritePMULLD", ".", "XMM", ",", "<NUM_LIT>", ">", ",", "<BUGS>", "VEX_4V", ",", "WIG", ";", "<BUGE>", "let", "Predicates", "=", "[", "HasAVX", "]", "indefm", "VPCMPEQQ", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "X86pcmpeq", ",", "v2i64", ",", "VR128", ",", "load", ",", "i128mem", ",", "SchedWriteVecALU", ".", "XMM", ",", "<NUM_LIT>", ">", ",", "<BUGS>", "VEX_4V", ",", "WIG", ";", "<BUGE>", "let", "Predicates", "=", "[", "HasAVX2", ",", "NoVLX", "]", "indefm", "VPMULLDY", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "mul", ",", "v8i32", ",", "VR256", ",", "load", ",", "i256mem", ",", "SchedWritePMULLD", ".", "YMM", ",", "<NUM_LIT>", ">", ",", "<BUGS>", "VEX_4V", ",", "VEX_L", ",", "WIG", ";", "<BUGE>", "let", "Predicates", "=", "[", "HasAVX2", "]", "indefm", "VPCMPEQQY", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "X86pcmpeq", ",", "v4i64", ",", "VR256", ",", "load", ",", "i256mem", ",", "SchedWriteVecALU", ".", "YMM", ",", "<NUM_LIT>", ">", ",", "<BUGS>", "VEX_4V", ",", "VEX_L", ",", "WIG", ";", "<BUGE>", "let", "Constraints", "=", "<STR_LIT>", "in", "{", "defm", "PMULLD", ":", "SS48I_binop_rm", "<NUM_LIT>", ",", "<STR_LIT>", ",", "mul", ",", "v4i32", ",", "VR128", "," ]

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

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

[ "}" ]

[ "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "getTheAAPTarget", "(", ")", ",", "createAAPMCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "getTheAAPTarget", "(", ")", ",", "createAAPMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "getTheAAPTarget", "(", ")", ",", "createAAPMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "getTheAAPTarget", "(", ")", ",", "createAAPMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "getTheAAPTarget", "(", ")", ",", "createAAPMCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "getTheAAPTarget", "(", ")", ",", "createAAPAsmBackend", ")", ";" ]

[ "tree", "aarch64_fold_builtin", "(", "tree", "fndecl", ",", "int", "n_args", "ATTRIBUTE_UNUSED", ",", "tree", "*", "args", ",", "bool", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "switch", "(", "fcode", ")", "{", "BUILTIN_VDQF", "(", "UNOP", ",", "abs", ",", "<NUM_LIT>", ")", "return", "fold_build1", "(", "ABS_EXPR", ",", "type", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "VAR1", "(", "UNOP", ",", "floatv2si", ",", "<NUM_LIT>", ",", "v2sf", ")", "VAR1", "(", "UNOP", ",", "floatv4si", ",", "<NUM_LIT>", ",", "v4sf", ")", "VAR1", "(", "UNOP", ",", "floatv2di", ",", "<NUM_LIT>", ",", "v2df", ")", "return", "fold_build1", "(", "FLOAT_EXPR", ",", "type", ",", "args", "[", "<NUM_LIT>", "]", ")", ";", "default", ":", "break", ";", "}", "return", "NULL_TREE", ";", "}" ]

[ "Implement", "TARGET_FOLD_BUILTIN", "." ]

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

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

[ "(", "*", "MF", ")", ";" ]

[ "MachineInstr", "*", "UseMI", "=", "Use", "->", "getParent", "(", ")", ";", "unsigned", "OpNo", "=", "Use", ".", "getOperandNo", "(", ")", ";", "if", "(", "OpToFold", ".", "isImm", "(", ")", "&&", "tryConstantFoldOp", "(", "*", "MRI", ",", "TII", ",", "UseMI", ",", "&", "OpToFold", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Constant folded ", "<STR_LIT>", "<<", "*", "UseMI", "<<", "'", "\\n", "'", ")", ";", "NextUse", "=", "MRI", "->", "use_begin", "(", "Dst", ".", "getReg", "(", ")", ")", ";", "FoldList", ".", "clear", "(", ")", ";", "continue", ";", "}", "if", "(", "isInlineConstantIfFolded", "(", "TII", ",", "*", "UseMI", ",", "OpNo", ",", "OpToFold", ")", ")", "{", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "OpNo", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "else", "{", "if", "(", "++", "NumLiteralUses", "==", "<NUM_LIT>", ")", "{", "NonInlineUse", "=", "&", "*", "Use", ";", "NonInlineUseOpNo", "=", "OpNo", ";", "}", "}", "}", "if", "(", "NumLiteralUses", "==", "<NUM_LIT>", ")", "{", "MachineInstr", "*", "UseMI", "=", "NonInlineUse", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "NonInlineUseOpNo", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "}", "else", "{", "SmallVector", "<", "MachineRegisterInfo", "::", "use_iterator", ",", "<NUM_LIT>", ">", "UsesToProcess", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "Use", "=", "MRI", "->", "use_begin", "(", "Dst", ".", "getReg", "(", ")", ")", ",", "E", "=", "MRI", "->", "use_end", "(", ")", ";", "Use", "!=", "E", ";", "++", "Use", ")", "{", "UsesToProcess", ".", "push_back", "(", "Use", ")", ";", "}", "for", "(", "auto", "U", ":", "UsesToProcess", ")", "{", "MachineInstr", "*", "UseMI", "=", "U", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "U", ".", "getOperandNo", "(", ")", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "}", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "for", "(", "MachineInstr", "*", "Copy", ":", "CopiesToReplace", ")", "Copy", "->", "addImplicitDefUseOperands" ]

[ "let", "BaseOpcode", "=", "<STR_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", "]", ";" ]

[ "rtx", "gen_datalabel_ref", "(", "rtx", "sym", ")", "{", "const", "char", "*", "str", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "LABEL_REF", ")", "return", "gen_rtx_CONST", "(", "GET_MODE", "(", "sym", ")", ",", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "sym", ")", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "sym", ")", ",", "UNSPEC_DATALABEL", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", ";", "str", "=", "XSTR", "(", "sym", ",", "<NUM_LIT>", ")", ";", "str", "=", "IDENTIFIER_POINTER", "(", "get_identifier", "(", "str", ")", ")", ";", "XSTR", "(", "sym", ",", "<NUM_LIT>", ")", "=", "str", ";", "return", "sym", ";", "}" ]

[ "Prefix", "a", "symbol_ref", "name", "with", "``", "datalabel", "''", "." ]

[ "}" ]

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

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

[ "def", "M2_mpyd_acc_ll_s1", ":", "T_M2_mpyd_acc", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "{", "mask", ",", "<NUM_LIT>", "," ]

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

[ "unsigned", "PPCTTIImpl", "::", "getCmpSelInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "ValTy", ",", "Type", "*", "CondTy", ")", "{", "return", "BaseT", "::", "getCmpSelInstrCost", "(", "Opcode", ",", "ValTy", "," ]

[ "AD_HLASM", ";" ]

[ "return", "getMAIAssemblerDialect", "(", ")", "==" ]

[ "G_SELECT", ":" ]

[ "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getMF", "(", ")", "->", "getRegInfo", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid opcode for custom legalization.", "<STR_LIT>", ")", ";", "case", "G_CONSTANT", ":", "return", "legalizeConstant", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SEXT", ":", "return", "legalizeSExt", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ZEXT", ":", "return", "legalizeZExt", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_BSWAP", ":", "return", "legalizeBSwap", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ADD", ":", "case", "G_SUB", ":", "return", "legalizeAddSub", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_XOR", ":", "return", "legalizeXor", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_SDIVREM", ":", "case", "G_UDIVREM", ":", "return", "legalizeDivRem", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_LSHR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_ROTL", ":", "case", "G_ROTR", ":", "return", "legalizeShiftRotate", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case", "G_ICMP", ":", "return", "legalizeICmp", "(", "Helper", ",", "MRI", ",", "MI", ")", ";", "case" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isPredicated", "=", "<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", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=" ]

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

[ "int", "AMDGPUCFGStructurizer", "::", "serialPatternMatch", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "if", "(", "MBB", "->", "succ_size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "MachineBasicBlock", "*", "childBlk", "=", "*", "MBB", "->", "succ_begin", "(", ")", ";", "if", "(", "childBlk", "->", "pred_size", "(", ")", "!=", "<NUM_LIT>", "||", "isActiveLoophead", "(", "childBlk", ")", ")", "return", "<NUM_LIT>", ";", "mergeSerialBlock", "(", "MBB", ",", "childBlk", ")", ";", "++", "numSerialPatternMatch", ";" ]

[ "false", ";" ]

[ "HOST_WIDE_INT", "i0", ";", "rtx", "temp", "=", "NULL_RTX", ";", "i0", "=", "alpha_extract_integer", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "temp", "=", "alpha_emit_set_const", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ",", "i0", ",", "<NUM_LIT>", ",", "false", ")", ";", "if", "(", "!", "temp", "&&", "TARGET_BUILD_CONSTANTS", ")", "temp", "=", "alpha_emit_set_long_const", "(", "operands", "[", "<NUM_LIT>", "]", ",", "i0", ")", ";", "if", "(", "temp", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "temp", ")", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "temp", ")", ";", "return", "true", ";", "}", "return" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=" ]

[ "<FIXS>", "MIs", ".", "erase", "(", "llvm", "::", "find", "(", "MIs", ",", "MI", ")", ",", "MIs", ".", "end", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "MIs", ".", "erase", "(", "llvm", "::", "find", "(", "MIs", ",", "MI", ")", ",", "MIs", ".", "end", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "const", "std", "::", "vector", "std", "::", "pair", "unsigned", ",", "unsigned", ">>", "&", "RemapChan", ")", "const", "{", "<FIXE>" ]

[ "for", "(", "InstructionSetMap", "::", "iterator", "It", "=", "PreviousRegSeqByReg", ".", "begin", "(", ")", ",", "E", "=", "PreviousRegSeqByReg", ".", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "std", "::", "vector", "MachineInstr", "*", ">", "&", "MIs", "=", "(", "*", "It", ")", ".", "second", ";", "<BUGS>", "MIs", ".", "erase", "(", "find", "(", "MIs", ",", "MI", ")", ",", "MIs", ".", "end", "(", ")", ")", ";", "<BUGE>", "}", "for", "(", "InstructionSetMap", "::", "iterator", "It", "=", "PreviousRegSeqByUndefCount", ".", "begin", "(", ")", ",", "E", "=", "PreviousRegSeqByUndefCount", ".", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "std", "::", "vector", "MachineInstr", "*", ">", "&", "MIs", "=", "(", "*", "It", ")", ".", "second", ";", "<BUGS>", "MIs", ".", "erase", "(", "find", "(", "MIs", ",", "MI", ")", ",", "MIs", ".", "end", "(", ")", ")", ";", "<BUGE>", "}", "}", "void", "R600VectorRegMerger", "::", "SwizzleInput", "(", "MachineInstr", "&", "MI", ",", "<BUGS>", "const", "std", "::", "vector", "std", "::", "pair", "unsigned", ",", "unsigned", ">", ">", "&", "RemapChan", ")", "const", "{", "<BUGE>", "unsigned", "Offset", ";", "if", "(", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "Offset", "=", "<NUM_LIT>", ";" ]

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

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_psubsw256_mask", "(", "(", "_", "_", "v16hi", ")", "_", "_", "A", ",", "(", "_", "_", "v16hi", ")", "_", "_", "B", ",", "(", "_", "_", "v16hi", ")", "_", "_", "W", "," ]

[ ")" ]

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

[ "SwapVector", ".", "clear", "(", ")", ";" ]

[ "TII", "=", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "int", "InitialVectorSize", "(", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "use-soft-float", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", "==", "<STR_LIT>", "true", "<STR_LIT>", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "<STR_LIT>", "+soft-float", "<STR_LIT>", ":", "<STR_LIT>", ",+soft-float", "<STR_LIT>", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "ARMGISelActualAccessor", "*", "GISel", "=", "new", "ARMGISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "ARMCallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "ARMLegalizerInfo", "(", "*", "I", ")", ")", ";", "auto", "*", "RBI", "=", "new", "ARMRegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "new", "ARMInstructionSelector", "(", "*", "I", ",", "*", "RBI", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";" ]

[ "v", ",", "node", ":", "$", "v", ")", ">", ";" ]

[ "def", "vsplati32_elt", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "v", ",", "node", ":", "$", "i", ")", ",", "(", "MipsVSHF", "(", "vsplati32", "node", ":", "$", "i", ")", ",", "node", ":", "$" ]

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

[ "def", "mrs_sysreg_op", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "MRSSystemRegisterOperand", ";" ]

[ "<STR_LIT>", ")" ]

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

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

[ "class", "sve_int_sel_vvv", "<", "bits", "<", "<NUM_LIT>", ">", "sz8_64", ",", "string", "asm", ",", "ZPRRegOp", "zprty", ">", ":", "I", "<", "(", "outs", "zprty", ":", "$", "Zd", ")", ",", "(", "ins", "PPRAny", ":", "$", "Pg", ",", "zprty", ":", "$", "Zn", ",", "zprty", ":", "$", "Zm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>" ]

[ "<FIXS>", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "<FIXE>" ]

[ "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "<BUGS>", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "code", ",", "speed", ")", ";", "<BUGE>", "return", "true", ";" ]

[ "::", "Scalar", ";" ]

[ "return", "Kind", "==", "k_Register", "&&", "Reg", ".", "Kind", "==", "RegKind" ]

[ ")", ")" ]

[ "[", "(", "set", "(", "reg", "CC_REGNUM", ")", "(", "compare", "(", "and", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "I48MODE", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "ScoreBrackets", ".", "applyWaitcnt", "(", "Wait", ")", ";" ]

[ "case", "SCMEM_GDS", ":", "if", "(", "group_is_multi_wave", "||", "fence_is_global", ")", "{", "EmitWaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ")", ";", "EmitWaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "LGKM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "LGKM_CNT", ")", ")", ";", "}", "break", ";", "case", "SCMEM_UAV", ":", "case", "SCMEM_TFBUF", ":", "case", "SCMEM_RING", ":", "case", "SCMEM_SCATTER", ":", "if", "(", "group_is_multi_wave", "||", "fence_is_global", ")", "{", "EmitWaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "EXP_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "EXP_CNT", ")", ")", ";", "EmitWaitcnt", "|=", "ScoreBrackets", "->", "updateByWait", "(", "VM_CNT", ",", "ScoreBrackets", "->", "getScoreUB", "(", "VM_CNT", ")", ")", ";", "}", "break", ";", "case", "SCMEM_SCRATCH", ":", "default", ":", "break", ";", "}", "}", "}", "else", "{", "if", "(", "MI", ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "if", "(", "ScoreBrackets", ".", "hasPendingEvent", "(", "EXP_GPR_LOCK", ")", "||", "ScoreBrackets", ".", "hasPendingEvent", "(", "EXP_PARAM_ACCESS", ")", "||", "ScoreBrackets", ".", "hasPendingEvent", "(", "EXP_POS_ACCESS", ")", "||", "ScoreBrackets", ".", "hasPendingEvent", "(", "GDS_GPR_LOCK", ")", ")", "{", "Wait", ".", "ExpCnt", "=", "<NUM_LIT>", ";", "}", "}", "if", "(", "MI", ".", "isCall", "(", ")", "&&", "callWaitsOnFunctionEntry", "(", "MI", ")", ")", "{", "Wait", "=", "AMDGPU", "::", "Waitcnt", "(", ")", ";", "int", "CallAddrOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "CallAddrOpIdx", ")", ".", "isReg", "(", ")", ")", "{", "RegInterval", "CallAddrOpInterval", "=", "ScoreBrackets", ".", "getRegInterval", "(", "&", "MI", ",", "TII", ",", "MRI", ",", "TRI", ",", "CallAddrOpIdx", ")", ";", "for", "(", "int", "RegNo", "=", "CallAddrOpInterval", ".", "first", ";", "RegNo", "<", "CallAddrOpInterval", ".", "second", ";", "++", "RegNo", ")", "ScoreBrackets", ".", "determineWait", "(", "LGKM_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "LGKM_CNT", ")", ",", "Wait", ")", ";", "int", "RtnAddrOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst", ")", ";", "if", "(", "RtnAddrOpIdx", "!=", "-", "<NUM_LIT>", ")", "{", "RegInterval", "RtnAddrOpInterval", "=", "ScoreBrackets", ".", "getRegInterval", "(", "&", "MI", ",", "TII", ",", "MRI", ",", "TRI", ",", "RtnAddrOpIdx", ")", ";", "for", "(", "int", "RegNo", "=", "RtnAddrOpInterval", ".", "first", ";", "RegNo", "<", "RtnAddrOpInterval", ".", "second", ";", "++", "RegNo", ")", "ScoreBrackets", ".", "determineWait", "(", "LGKM_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "LGKM_CNT", ")", ",", "Wait", ")", ";", "}", "}", "}", "else", "{", "for", "(", "const", "MachineMemOperand", "*", "Memop", ":", "MI", ".", "memoperands", "(", ")", ")", "{", "const", "Value", "*", "Ptr", "=", "Memop", "->", "getValue", "(", ")", ";", "if", "(", "Memop", "->", "isStore", "(", ")", "&&", "SLoadAddresses", ".", "count", "(", "Ptr", ")", ")", "{", "addWait", "(", "Wait", ",", "LGKM_CNT", ",", "<NUM_LIT>", ")", ";", "if", "(", "PDT", "->", "dominates", "(", "MI", ".", "getParent", "(", ")", ",", "SLoadAddresses", ".", "find", "(", "Ptr", ")", "->", "second", ")", ")", "SLoadAddresses", ".", "erase", "(", "Ptr", ")", ";", "}", "unsigned", "AS", "=", "Memop", "->", "getAddrSpace", "(", ")", ";", "if", "(", "AS", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "unsigned", "RegNo", "=", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ";", "ScoreBrackets", ".", "determineWait", "(", "VM_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "VM_CNT", ")", ",", "Wait", ")", ";", "if", "(", "Memop", "->", "isStore", "(", ")", ")", "{", "ScoreBrackets", ".", "determineWait", "(", "EXP_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "EXP_CNT", ")", ",", "Wait", ")", ";", "}", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "RegInterval", "Interval", "=", "ScoreBrackets", ".", "getRegInterval", "(", "&", "MI", ",", "TII", ",", "MRI", ",", "TRI", ",", "I", ")", ";", "const", "bool", "IsVGPR", "=", "TRI", "->", "isVectorRegister", "(", "*", "MRI", ",", "Op", ".", "getReg", "(", ")", ")", ";", "for", "(", "int", "RegNo", "=", "Interval", ".", "first", ";", "RegNo", "<", "Interval", ".", "second", ";", "++", "RegNo", ")", "{", "if", "(", "IsVGPR", ")", "{", "if", "(", "Op", ".", "isUse", "(", ")", "||", "!", "SIInstrInfo", "::", "isVMEM", "(", "MI", ")", "||", "ScoreBrackets", ".", "hasOtherPendingVmemTypes", "(", "RegNo", ",", "getVmemType", "(", "MI", ")", ")", ")", "{", "ScoreBrackets", ".", "determineWait", "(", "VM_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "VM_CNT", ")", ",", "Wait", ")", ";", "ScoreBrackets", ".", "clearVgprVmemTypes", "(", "RegNo", ")", ";", "}", "if", "(", "Op", ".", "isDef", "(", ")", ")", "{", "ScoreBrackets", ".", "determineWait", "(", "EXP_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "EXP_CNT", ")", ",", "Wait", ")", ";", "}", "}", "ScoreBrackets", ".", "determineWait", "(", "LGKM_CNT", ",", "ScoreBrackets", ".", "getRegScore", "(", "RegNo", ",", "LGKM_CNT", ")", ",", "Wait", ")", ";", "}", "}", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", "&&", "!", "ST", "->", "hasAutoWaitcntBeforeBarrier", "(", ")", ")", "{", "Wait", "=", "Wait", ".", "combined", "(", "AMDGPU", "::", "Waitcnt", "::", "allZero", "(", "ST", "->", "hasVscnt", "(", ")", ")", ")", ";", "}", "if", "(", "readsVCCZ", "(", "MI", ")", "&&", "ST", "->", "hasReadVCCZBug", "(", ")", ")", "{", "if", "(", "ScoreBrackets", ".", "getScoreLB", "(", "LGKM_CNT", ")", "<", "ScoreBrackets", ".", "getScoreUB", "(", "LGKM_CNT", ")", "&&", "ScoreBrackets", ".", "hasPendingEvent", "(", "SMEM_ACCESS", ")", ")", "{", "Wait", ".", "LgkmCnt", "=", "<NUM_LIT>", ";", "}", "}", "ScoreBrackets", ".", "simplifyWaitcnt", "(", "Wait", ")", ";", "if", "(", "ForceEmitZeroWaitcnts", ")", "Wait", "=", "AMDGPU", "::", "Waitcnt", "::", "allZero", "(", "ST", "->", "hasVscnt", "(", ")", ")", ";", "if", "(", "ForceEmitWaitcnt", "[", "VM_CNT", "]", ")", "Wait", ".", "VmCnt", "=", "<NUM_LIT>", ";", "if", "(", "ForceEmitWaitcnt", "[", "EXP_CNT", "]", ")", "Wait", ".", "ExpCnt", "=", "<NUM_LIT>", ";", "if", "(", "ForceEmitWaitcnt", "[", "LGKM_CNT", "]", ")", "Wait", ".", "LgkmCnt", "=", "<NUM_LIT>", ";", "if", "(", "ForceEmitWaitcnt", "[", "VS_CNT", "]", ")", "Wait", ".", "VsCnt", "=", "<NUM_LIT>", ";", "if", "(", "OldWaitcntInstr", ")", "{", "Modified", "=", "applyPreexistingWaitcnt", "(", "ScoreBrackets", ",", "*", "OldWaitcntInstr", ",", "Wait", ",", "&", "MI", ")", ";", "}", "else", "{" ]

[ "}" ]

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

[ "setOperationAction", "(", "ISD", "::", "UNDEF", ",", "VT", ",", "Legal", ")", ";" ]

[ "void", "ARMTargetLowering", "::", "setAllExpand", "(", "MVT", "VT", ")", "{", "for", "(", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "Opc", "<", "ISD", "::", "BUILTIN_OP_END", ";", "++", "Opc", ")", "setOperationAction", "(", "Opc", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BITCAST", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "VT", ",", "Legal", ")", ";" ]

[ "HasVirtualization", "=", "false", ";" ]

[ "HasV4TOps", "=", "false", ";", "HasV5TOps", "=", "false", ";", "HasV5TEOps", "=", "false", ";", "HasV6Ops", "=", "false", ";", "HasV6MOps", "=", "false", ";", "HasV6KOps", "=", "false", ";", "HasV6T2Ops", "=", "false", ";", "HasV7Ops", "=", "false", ";", "HasV8Ops", "=", "false", ";", "HasV8_1aOps", "=", "false", ";", "HasV8_2aOps", "=", "false", ";", "HasV8MBaselineOps", "=", "false", ";", "HasV8MMainlineOps", "=", "false", ";", "HasVFPv2", "=", "false", ";", "HasVFPv3", "=", "false", ";", "HasVFPv4", "=", "false", ";", "HasFPARMv8", "=", "false", ";", "HasNEON", "=", "false", ";", "UseNEONForSinglePrecisionFP", "=", "false", ";", "UseMulOps", "=", "UseFusedMulOps", ";", "SlowFPVMLx", "=", "false", ";", "HasVMLxForwarding", "=", "false", ";", "SlowFPBrcc", "=", "false", ";", "InThumbMode", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasThumb2", "=", "false", ";", "NoARM", "=", "false", ";", "ReserveR9", "=", "false", ";", "NoMovt", "=", "false", ";", "SupportsTailCall", "=", "false", ";", "HasFP16", "=", "false", ";", "HasFullFP16", "=", "false", ";", "HasD16", "=", "false", ";", "HasHardwareDivide", "=", "false", ";", "HasHardwareDivideInARM", "=", "false", ";", "HasT2ExtractPack", "=", "false", ";", "HasDataBarrier", "=", "false", ";", "Pref32BitThumb", "=", "false", ";", "AvoidCPSRPartialUpdate", "=", "false", ";", "AvoidMOVsShifterOperand", "=", "false", ";", "HasRAS", "=", "false", ";", "HasMPExtension", "=", "false", ";" ]

[ "}" ]

[ "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "<STR_LIT>", "Isn't a symbol reference", "<STR_LIT>", ")", ";", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "Mang", ")", ";", "}", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "return", "Sym", ";" ]

[ "}" ]

[ "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetGlobalAddress", ")", "return", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ";", "Optional", "<", "ConstantRange", ">", "CR", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "N", ")", "->", "getGlobal", "(", ")", "->", "getAbsoluteSymbolRange", "(", ")", ";", "if", "(", "!", "CR", ")", "return", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ";", "return", "CR", "->", "getUnsignedMax", "(", ")", ".", "ult", "(", "<NUM_LIT>", "ull", "<<", "<NUM_LIT>", ")", ";" ]

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

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "wrssd", "(", "unsigned", "int", "_", "_", "B", ",", "void", "*", "_", "_", "C", ")", "{", "_", "_", "builtin_ia32_wrssd", "(", "_", "_", "B", ",", "_", "_", "C", ")", ";" ]

[ "static", "unsigned", "int", "get_csky_live_regs", "(", "int", "*", "count", ")", "{", "int", "reg", ";", "unsigned", "int", "live_regs_mask", "=", "<NUM_LIT>", ";", "*", "count", "=", "<NUM_LIT>", ";", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<", "CSKY_NGPR_REGS", ";", "reg", "++", ")", "{", "bool", "save", "=", "false", ";", "if", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "&&", "reg", ">", "<NUM_LIT>", "&&", "reg", "<", "<NUM_LIT>", ")", "continue", ";", "if", "(", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "||", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK803", ")", ")", "&&", "reg", ">", "<NUM_LIT>", ")", "break", ";", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "save", "=", "true", ";", "else", "if", "(", "frame_pointer_needed", "&&", "reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", "save", "=", "true", ";", "else", "if", "(", "crtl", "->", "calls_eh_return", "&&", "reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", "save", "=", "true", ";", "else", "if", "(", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "||", "CSKY_TARGET_ARCH", "(", "CK802", ")", ")", "&&", "reg", "==", "CSKY_LR_REGNUM", "&&", "(", "!", "crtl", "->", "is_leaf", "||", "csky_far_jump_used_p", "(", ")", ")", ")", "save", "=", "true", ";", "else", "if", "(", "crtl", "->", "calls_eh_return", "&&", "reg", ">=", "CSKY_FIRST_EH_RETDATA_REGNUM", "&&", "reg", "<=", "CSKY_LAST_EH_RETDATA_REGNUM", ")", "save", "=", "true", ";", "if", "(", "reg", "==", "CSKY_STACKADJUST_REGNUM", "&&", "cfun", "->", "machine", "->", "reg_offset", ">", "CSKY_MAX_SP_ADJUST", "*", "<NUM_LIT>", ")", "save", "=", "true", ";", "if", "(", "save", ")", "{", "(", "*", "count", ")", "++", ";", "live_regs_mask", "|=", "(", "<NUM_LIT>", "<<", "reg", ")", ";", "}", "}", "return", "live_regs_mask", ";", "}" ]

[ "Return", "the", "mask", "of", "registers", "used", "by", "the", "current", "function", ".", "Set", "COUNT", "to", "the", "number", "of", "registers", "used", "." ]