Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_MODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "-", "63", "<=", "jump_distance", "&&", "jump_distance", "<=", "62", ")", "return", "1", ";", "else", "if", "(", "-", "2046", "<=", "jump_distance", "&&", "jump_distance", "<=", "2045", ")", "return", "2", ";", "else", "if", "(", "AVR_MEGA", ")", "return", "3", ";", "return", "2", ";", "}", "</s>" ]

[ "Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "." ]

[ "avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "restoreWin32EHStackPointers", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "DL", ",", "bool", "RestoreSP", ")", "const", "{", "assert", "(", "STI", ".", "isTargetWindowsMSVC", "(", ")", "&&", "\"funclets only supported in MSVC env\"", ")", ";", "assert", "(", "STI", ".", "isTargetWin32", "(", ")", "&&", "\"EBP/ESI restoration only required on win32\"", ")", ";", "assert", "(", "STI", ".", "is32Bit", "(", ")", "&&", "!", "Uses64BitFramePtr", "&&", "\"restoring EBP/ESI on non-32-bit target\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "BasePtr", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "FuncInfo", ".", "EHRegNodeFrameIndex", ";", "int", "EHRegSize", "=", "MFI", "->", "getObjectSize", "(", "FI", ")", ";", "if", "(", "RestoreSP", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "ESP", ")", ",", "X86", "::", "EBP", ",", "true", ",", "-", "EHRegSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "unsigned", "UsedReg", ";", "int", "EHRegOffset", "=", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "UsedReg", ")", ";", "int", "EndOffset", "=", "-", "EHRegOffset", "-", "EHRegSize", ";", "FuncInfo", ".", "EHRegNodeEndOffset", "=", "EndOffset", ";", "if", "(", "UsedReg", "==", "FramePtr", ")", "{", "unsigned", "ADDri", "=", "getADDriOpcode", "(", "false", ",", "EndOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "ADDri", ")", ",", "FramePtr", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "assert", "(", "EndOffset", ">=", "0", "&&", "\"end of registration object above normal EBP position!\"", ")", ";", "}", "else", "if", "(", "UsedReg", "==", "BasePtr", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "BasePtr", ")", ",", "FramePtr", ",", "false", ",", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "assert", "(", "X86FI", "->", "getHasSEHFramePtrSave", "(", ")", ")", ";", "int", "Offset", "=", "getFrameIndexReference", "(", "MF", ",", "X86FI", "->", "getSEHFramePtrSaveIndex", "(", ")", ",", "UsedReg", ")", ";", "assert", "(", "UsedReg", "==", "BasePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "FramePtr", ")", ",", "UsedReg", ",", "true", ",", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"", ")", ";", "}", "return", "MBBI", ";", "}", "</s>" ]

[ "Sets", "up", "EBP", "and", "optionally", "ESI", "based", "on", "the", "incoming", "EBP", "value", "." ]

[ "X86", "X86", "\"funclets only supported in MSVC env\"", "\"EBP/ESI restoration only required on win32\"", "\"restoring EBP/ESI on non-32-bit target\"", "X86", "X86", "X86", "X86::MOV32rm", "X86::ESP", "X86::EBP", "3", "0", "\"end of registration object above normal EBP position!\"", "X86::LEA32r", "X86", "X86", "X86::MOV32rm", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"" ]

[]

[ "<s>", "int", "rl78_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "rv", "=", "0", ";", "rl78_compute_frame_info", "(", ")", ";", "switch", "(", "to", ")", "{", "case", "STACK_POINTER_REGNUM", ":", "rv", "+=", "cfun", "->", "machine", "->", "framesize_outgoing", ";", "rv", "+=", "cfun", "->", "machine", "->", "framesize_locals", ";", "case", "FRAME_POINTER_REGNUM", ":", "rv", "+=", "cfun", "->", "machine", "->", "framesize_regs", ";", "rv", "+=", "4", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "rv", "-=", "4", ";", "rv", "-=", "cfun", "->", "machine", "->", "framesize_regs", ";", "case", "ARG_POINTER_REGNUM", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "rv", ";", "}", "</s>" ]

[ "Implements", "INITIAL_ELIMINATION_OFFSET", ".", "The", "frame", "layout", "is", "described", "in", "the", "machine_Function", "struct", "definition", ",", "above", "." ]

[ "rl78", "0", "4", "4" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_xcoff_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "align", ";", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "VAR_P", "(", "decl", ")", "&&", "bss_initializer_p", "(", "decl", ")", ")", "flags", "|=", "SECTION_BSS", ";", "if", "(", "!", "decl", "||", "!", "DECL_P", "(", "decl", ")", ")", "align", "=", "MIN_UNITS_PER_WORD", ";", "else", "if", "(", "(", "flags", "&", "SECTION_CODE", ")", "!=", "0", ")", "align", "=", "MAX", "(", "(", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ",", "32", ")", ";", "else", "align", "=", "MAX", "(", "(", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ",", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ">", "MIN_UNITS_PER_WORD", "?", "UNITS_PER_FP_WORD", ":", "MIN_UNITS_PER_WORD", ")", ";", "return", "flags", "|", "(", "exact_log2", "(", "align", ")", "&", "SECTION_ENTSIZE", ")", ";", "}", "</s>" ]

[ "Section", "attributes", ".", "AIX", "is", "always", "PIC", "." ]

[ "rs6000", "0", "32" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "supportsTailCall", "(", ")", ")", "return", "false", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "split_di", "(", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "4", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "0", ")", ";", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "4", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "DImode", "RTL", "references", "into", "pairs", "of", "SImode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "DImode", "RTL", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

[ "m68k", "4", "0", "4", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "X86", "0" ]

[]

[ "<s>", "static", "rtx", "mips_add_offset", "(", "rtx", "temp", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "!", "SMALL_OPERAND", "(", "offset", ")", ")", "{", "rtx", "high", ";", "if", "(", "TARGET_MIPS16", ")", "{", "high", "=", "GEN_INT", "(", "offset", ")", ";", "offset", "=", "0", ";", "}", "else", "{", "high", "=", "gen_int_mode", "(", "CONST_HIGH_PART", "(", "offset", ")", ",", "Pmode", ")", ";", "offset", "=", "CONST_LOW_PART", "(", "offset", ")", ";", "}", "high", "=", "mips_force_temporary", "(", "temp", ",", "high", ")", ";", "reg", "=", "mips_force_temporary", "(", "temp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "high", ",", "reg", ")", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ";", "}", "</s>" ]

[ "Return", "a", "legitimate", "address", "for", "REG", "+", "OFFSET", ".", "TEMP", "is", "as", "for", "mips_force_temporary", ";", "it", "is", "only", "needed", "when", "OFFSET", "is", "not", "a", "SMALL_OPERAND", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_pre_modify_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "&", "RELOAD_REG_PRE_MODIFY", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "say", "whether", "a", "mode", "supports", "PRE_MODIFY", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "static", "bool", "arm_xscale_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "*", "total", "=", "thumb_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "switch", "(", "code", ")", "{", "case", "MULT", ":", "if", "(", "mode", "==", "DImode", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SIGN_EXTEND", ")", ")", "{", "*", "total", "=", "8", ";", "return", "true", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "DImode", ")", "{", "*", "total", "=", "30", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", ";", "int", "cost", ",", "const_ok", "=", "const_ok_for_arm", "(", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "masked_const", ";", "cost", "=", "2", ";", "if", "(", "!", "const_ok", ")", "cost", "+=", "1", ";", "masked_const", "=", "i", "&", "0xffff8000", ";", "if", "(", "masked_const", "!=", "0", "&&", "masked_const", "!=", "0xffff8000", ")", "{", "masked_const", "=", "i", "&", "0xf8000000", ";", "if", "(", "masked_const", "==", "0", "||", "masked_const", "==", "0xf8000000", ")", "cost", "+=", "1", ";", "else", "cost", "+=", "2", ";", "}", "*", "total", "=", "cost", ";", "return", "true", ";", "}", "*", "total", "=", "8", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "0", ")", ")", "?", "0", ":", "4", ")", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "0", ":", "4", ")", ";", "return", "true", ";", "case", "COMPARE", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MULT", ")", "*", "total", "=", "4", "+", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "code", ")", ";", "else", "*", "total", "=", "arm_rtx_costs_1", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "default", ":", "*", "total", "=", "arm_rtx_costs_1", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "RTX", "cost", "for", "XScale", "CPUs", ".", "Thumb-2", "is", "not", "supported", "on", "any", "xscale", "cores", ",", "so", "it", "can", "be", "ignored", "." ]

[ "arm", "0", "1", "0", "0", "8", "30", "1", "1", "0xffffffff", "2", "1", "0xffff8000", "0", "0xffff8000", "0xf8000000", "0", "0xf8000000", "1", "2", "8", "0", "0", "4", "1", "0", "4", "0", "4", "0" ]

[]

[ "<s>", "static", "rtx", "avr_find_unused_d_reg", "(", "rtx_insn", "*", "insn", ",", "rtx", "exclude", ")", "{", "bool", "isr_p", "=", "(", "avr_interrupt_function_p", "(", "current_function_decl", ")", "||", "avr_signal_function_p", "(", "current_function_decl", ")", ")", ";", "for", "(", "int", "regno", "=", "16", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "rtx", "reg", "=", "all_regs_rtx", "[", "regno", "]", ";", "if", "(", "(", "exclude", "&&", "reg_overlap_mentioned_p", "(", "exclude", ",", "reg", ")", ")", "||", "fixed_regs", "[", "regno", "]", ")", "{", "continue", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", "||", "(", "!", "isr_p", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", ")", "{", "return", "reg", ";", "}", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "reg_unused_after", "(", "insn", ",", "reg", ")", ")", "{", "return", "reg", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Fixme", ":", "This", "is", "a", "hack", "because", "secondary", "reloads", "do", "n't", "works", "as", "expected", ".", "Find", "an", "unused", "d-register", "to", "be", "used", "as", "scratch", "in", "INSN", ".", "EXCLUDE", "is", "either", "NULL_RTX", "or", "some", "register", ".", "In", "the", "case", "where", "EXCLUDE", "is", "a", "register", ",", "skip", "all", "possible", "return", "values", "that", "overlap", "EXCLUDE", ".", "The", "policy", "for", "the", "returned", "register", "is", "similar", "to", "that", "of", "`", "reg_unused_after", "'", ",", "i.e", ".", "the", "returned", "register", "may", "overlap", "the", "SET_DEST", "of", "INSN", ".", "Return", "a", "QImode", "d-register", "or", "NULL_RTX", "if", "nothing", "found", "." ]

[ "avr", "16", "32" ]

[]

[ "<s>", "rtx", "tilegx_simd_int", "(", "rtx", "num", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "n", "=", "0", ";", "gcc_assert", "(", "CONST_INT_P", "(", "num", ")", ")", ";", "n", "=", "INTVAL", "(", "num", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "n", "=", "0x0101010101010101LL", "*", "(", "n", "&", "0x000000FF", ")", ";", "break", ";", "case", "HImode", ":", "n", "=", "0x0001000100010001LL", "*", "(", "n", "&", "0x0000FFFF", ")", ";", "break", ";", "case", "SImode", ":", "n", "=", "0x0000000100000001LL", "*", "(", "n", "&", "0xFFFFFFFF", ")", ";", "break", ";", "case", "DImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "GEN_INT", "(", "n", ")", ";", "}", "</s>" ]

[ "Return", "the", "simd", "variant", "of", "the", "constant", "NUM", "of", "mode", "MODE", ",", "by", "replicating", "it", "to", "fill", "an", "interger", "of", "mode", "DImode", ".", "NUM", "is", "first", "truncated", "to", "fit", "in", "MODE", "." ]

[ "tilegx", "0", "0x0101010101010101LL", "0x000000FF", "0x0001000100010001LL", "0x0000FFFF", "0x0000000100000001LL", "0xFFFFFFFF" ]

[]

[ "<s>", "void", "m32c_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "ca", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", ",", "int", "n_named_args", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "fntype", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ")", "ca", "->", "force_mem", "=", "1", ";", "else", "ca", "->", "force_mem", "=", "0", ";", "ca", "->", "parm_num", "=", "1", ";", "}", "</s>" ]

[ "Implements", "INIT_CUMULATIVE_ARGS", "." ]

[ "m32c", "1", "0", "1" ]

[]

[ "<s>", "bool", "SparcInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "{", "assert", "(", "Subtarget", ".", "isTargetLinux", "(", ")", "&&", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", ")", ";", "const", "int64_t", "Offset", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "0x28", ":", "0x14", ";", "MI", ".", "setDesc", "(", "get", "(", "Subtarget", ".", "is64Bit", "(", ")", "?", "SP", "::", "LDXri", ":", "SP", "::", "LDri", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addReg", "(", "SP", "::", "G7", ")", ".", "addImm", "(", "Offset", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Sparc", "Sparc", "\"Only Linux target is expected to contain LOAD_STACK_GUARD\"", "0x28", "0x14", "SP::LDXri", "SP::LDri", "SP::G7" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "\"Empty shufflevector input\"", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "\"Unmatched number of shufflevectors and indices\"", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "0", "]", "->", "getType", "(", ")", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", ";", "bool", "EltIs64Bits", "=", "DL", ".", "getTypeAllocSizeInBits", "(", "EltTy", ")", "==", "64", ";", "if", "(", "(", "VecSize", "!=", "64", "&&", "VecSize", "!=", "128", ")", "||", "EltIs64Bits", ")", "return", "false", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "arm_neon_vld2", ",", "Intrinsic", "::", "arm_neon_vld3", ",", "Intrinsic", "::", "arm_neon_vld4", "}", ";", "Function", "*", "VldnFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "2", "]", ",", "VecTy", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "SmallVector", "<", "Value", "*", ",", "2", ">", "Ops", ";", "Type", "*", "Int8Ptr", "=", "Builder", ".", "getInt8PtrTy", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "Int8Ptr", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "getInt32", "(", "LI", "->", "getAlignment", "(", ")", ")", ")", ";", "CallInst", "*", "VldN", "=", "Builder", ".", "CreateCall", "(", "VldnFunc", ",", "Ops", ",", "\"vldN\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SV", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "VldN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SV", "->", "getType", "(", ")", ")", ";", "SV", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "ARM", "ARM", "2", "\"Invalid interleave factor\"", "\"Empty shufflevector input\"", "\"Unmatched number of shufflevectors and indices\"", "0", "64", "64", "128", "Intrinsic::ID", "3", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::getDeclaration", "2", "2", "\"vldN\"", "0" ]

[]

[ "<s>", "bool", "BPFTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "BPF", "BPF", "0", "1" ]

[]

[ "<s>", "void", "WDC65816TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "WDC65816", "WDC", "0", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "FISCTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "FISCPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "FISC", "FISC", "FISC" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented __builtin_return_address\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "\"WebAssembly hasn't implemented __builtin_return_address\"", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::INTRINSIC_WO_CHAIN", "ISD::VECTOR_SHUFFLE", "ISD::SHL", "ISD::SRA", "ISD::SRL" ]

[]

[ "<s>", "void", "NyuziFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "NyuziInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "NyuziInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Nyuzi", "::", "RET", "&&", "\"Can only put epilog before 'retl' instruction!\"", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "Nyuzi", "::", "MOVESS", ")", ")", ".", "addReg", "(", "Nyuzi", "::", "SP_REG", ")", ".", "addReg", "(", "Nyuzi", "::", "FP_REG", ")", ";", "}", "uint64_t", "StackSize", "=", "alignTo", "(", "MFI", ".", "getStackSize", "(", ")", ",", "getStackAlignment", "(", ")", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPointer", "(", "MBB", ",", "MBBI", ",", "DL", ",", "StackSize", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi::RET", "\"Can only put epilog before 'retl' instruction!\"", "0", "Nyuzi::MOVESS", "Nyuzi::SP_REG", "Nyuzi::FP_REG" ]

[]

[ "<s>", "bool", "isConstantSplat", "(", "SDValue", "Op", ",", "APInt", "&", "SplatVal", ",", "bool", "AllowPartialUndefs", ")", "{", "APInt", "UndefElts", ";", "SmallVector", "<", "APInt", ",", "16", ">", "EltBits", ";", "if", "(", "getTargetConstantBitsFromNode", "(", "Op", ",", "Op", ".", "getScalarValueSizeInBits", "(", ")", ",", "UndefElts", ",", "EltBits", ",", "true", ",", "AllowPartialUndefs", ")", ")", "{", "int", "SplatIndex", "=", "-", "1", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "EltBits", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "UndefElts", "[", "i", "]", ")", "continue", ";", "if", "(", "0", "<=", "SplatIndex", "&&", "EltBits", "[", "i", "]", "!=", "EltBits", "[", "SplatIndex", "]", ")", "{", "SplatIndex", "=", "-", "1", ";", "break", ";", "}", "SplatIndex", "=", "i", ";", "}", "if", "(", "0", "<=", "SplatIndex", ")", "{", "SplatVal", "=", "EltBits", "[", "SplatIndex", "]", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "this", "is", "a", "constant", "splat", ",", "and", "if", "so", ",", "find", "the", "smallest", "element", "size", "that", "splats", "the", "vector", "." ]

[ "X86", "16", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "XCoreInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "if", "(", "Size", ">", "HEXAGON_MAX_PACKET_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "HexagonMCChecker", "Checker", "(", "*", "MCII", ",", "STI", ",", "MI", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_ri", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ",", "uint64_t", "Imm", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "a", "register", "operand", ",", "an", "immediate", ",", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "ARM", "ARM", "1", "1", "0" ]

[]

[ "<s>", "MipsCCState", "::", "SpecialCallingConvType", "MipsCCState", "::", "getSpecialCallingConvForCallee", "(", "const", "SDNode", "*", "Callee", ",", "const", "MipsSubtarget", "&", "Subtarget", ")", "{", "MipsCCState", "::", "SpecialCallingConvType", "SpecialCallingConv", "=", "NoSpecialCallingConv", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "const", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "llvm", "::", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "SpecialCallingConv", "=", "Mips16RetHelperConv", ";", "}", "}", "}", "return", "SpecialCallingConv", ";", "}", "</s>" ]

[ "Determine", "the", "SpecialCallingConvType", "for", "the", "given", "callee", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"__Mips16RetHelper\"", "Mips" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_vec_ext_builtin", "(", "tree", "arglist", ",", "rtx", "target", ")", "{", "enum", "machine_mode", "tmode", ",", "mode0", ";", "tree", "arg0", ",", "arg1", ";", "int", "elt", ";", "rtx", "op0", ";", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "elt", "=", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg1", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "mode0", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", ";", "op0", "=", "force_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "optimize", "||", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "ix86_expand_vector_extract", "(", "true", ",", "target", ",", "op0", ",", "elt", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_builtin", ".", "These", "builtins", "are", "a", "wrapper", "around", "ix86_expand_vector_extract", ".", "They", "would", "be", "redundant", "(", "for", "non-MMX", ")", "if", "we", "had", "a", "language-level", "syntax", "for", "referencing", "vector", "elements", "." ]

[ "i386", "0" ]

[]

[ "<s>", "static", "void", "hwloop_fail", "(", "hwloop_info", "loop", ")", "{", "rtx", "test", ";", "rtx", "insn", "=", "loop", "->", "loop_end", ";", "if", "(", "TARGET_DBNZ", "&&", "(", "loop", "->", "length", "&&", "(", "loop", "->", "length", "<=", "ARC_MAX_LOOP_LENGTH", ")", ")", "&&", "REG_P", "(", "loop", "->", "iter_reg", ")", ")", "{", "test", "=", "gen_dbnz", "(", "loop", "->", "iter_reg", ",", "loop", "->", "start_label", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "test", ",", "loop", "->", "loop_end", ")", ";", "}", "else", "if", "(", "REG_P", "(", "loop", "->", "iter_reg", ")", "&&", "(", "REGNO", "(", "loop", "->", "iter_reg", ")", "==", "LP_COUNT", ")", ")", "{", "emit_insn_before", "(", "gen_loop_fail", "(", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CC_ZNmode", ",", "CC_REG", ")", ",", "const0_rtx", ")", ";", "test", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "test", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "loop", "->", "start_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "test", ")", ",", "loop", "->", "loop_end", ")", ";", "}", "else", "{", "emit_insn_before", "(", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_cbranchsi4", "(", "test", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ",", "loop", "->", "start_label", ")", ",", "loop", "->", "loop_end", ")", ";", "}", "JUMP_LABEL", "(", "insn", ")", "=", "loop", "->", "start_label", ";", "LABEL_NUSES", "(", "loop", "->", "start_label", ")", "++", ";", "delete_insn", "(", "loop", "->", "loop_end", ")", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "when", "a", "loop", "we", "have", "discovered", "turns", "out", "not", "to", "be", "optimizable", ";", "we", "have", "to", "split", "the", "doloop_end", "pattern", "into", "a", "subtract", "and", "a", "test", "." ]

[ "arc" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "MINA32", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "MINA32", "MINA32::NumTargetFixupKinds" ]

[]

[ "<s>", "unsigned", "stackAlignment", "(", ")", "const", "{", "return", "8", ";", "}", "</s>" ]

[ "The", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "." ]

[ "SIC", "8" ]

[]

[ "<s>", "rtx", "xtensa_builtin_saveregs", "(", ")", "{", "rtx", "gp_regs", ",", "dest", ";", "int", "arg_words", "=", "current_function_arg_words", ";", "int", "gp_left", "=", "MAX_ARGS_IN_REGISTERS", "-", "arg_words", ";", "int", "i", ";", "if", "(", "gp_left", "==", "0", ")", "return", "const0_rtx", ";", "gp_regs", "=", "assign_stack_local", "(", "BLKmode", ",", "MAX_ARGS_IN_REGISTERS", "*", "UNITS_PER_WORD", ",", "-", "1", ")", ";", "MEM_IN_STRUCT_P", "(", "gp_regs", ")", "=", "1", ";", "RTX_UNCHANGING_P", "(", "gp_regs", ")", "=", "1", ";", "RTX_UNCHANGING_P", "(", "XEXP", "(", "gp_regs", ",", "0", ")", ")", "=", "1", ";", "dest", "=", "change_address", "(", "gp_regs", ",", "SImode", ",", "plus_constant", "(", "XEXP", "(", "gp_regs", ",", "0", ")", ",", "arg_words", "*", "UNITS_PER_WORD", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "gp_left", ";", "i", "++", ")", "{", "emit_move_insn", "(", "operand_subword", "(", "dest", ",", "i", ",", "1", ",", "BLKmode", ")", ",", "gen_raw_REG", "(", "SImode", ",", "GP_ARG_FIRST", "+", "arg_words", "+", "i", ")", ")", ";", "}", "return", "XEXP", "(", "gp_regs", ",", "0", ")", ";", "}", "</s>" ]

[ "Save", "the", "incoming", "argument", "registers", "on", "the", "stack", ".", "Returns", "the", "address", "of", "the", "saved", "registers", "." ]

[ "xtensa", "0", "1", "1", "1", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "Register", "RISCVTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "MatchRegisterAltName", "(", "RegName", ")", ";", "if", "(", "Reg", "==", "RISCV", "::", "NoRegister", ")", "Reg", "=", "MatchRegisterName", "(", "RegName", ")", ";", "if", "(", "Reg", "==", "RISCV", "::", "NoRegister", ")", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "BitVector", "ReservedRegs", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", "->", "getReservedRegs", "(", "MF", ")", ";", "if", "(", "!", "ReservedRegs", ".", "test", "(", "Reg", ")", "&&", "!", "Subtarget", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "report_fatal_error", "(", "Twine", "(", "\"Trying to obtain non-reserved register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "RI5CY", "RISCV", "RISCV::NoRegister", "RISCV::NoRegister", "\"Invalid register name \\\"\"", "\"\\\".\"", "\"Trying to obtain non-reserved register \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "unsigned", "Tile64InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Tile64", "0" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "reduceLoopCount", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "*", "IndVar", ",", "MachineInstr", "&", "Cmp", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "PrevInsts", ",", "unsigned", "Iter", ",", "unsigned", "MaxIter", ")", "const", "{", "assert", "(", "(", "!", "IndVar", ")", "&&", "isEndLoopN", "(", "Cmp", ".", "getOpcode", "(", ")", ")", "&&", "\"Expecting a hardware loop\"", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "VisitedBBs", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "&", "MBB", ",", "Cmp", ".", "getOpcode", "(", ")", ",", "Cmp", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ",", "VisitedBBs", ")", ";", "if", "(", "!", "Loop", ")", "return", "0", ";", "if", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0i", "||", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop1i", ")", "{", "int64_t", "Offset", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "1", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "else", "Loop", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "Offset", "-", "1", ")", ";", "return", "Offset", "-", "1", ";", "}", "assert", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0r", "&&", "\"Unexpected instruction\"", ")", ";", "unsigned", "LoopCount", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "LoopEnd", "=", "createVR", "(", "MF", ",", "MVT", "::", "i1", ")", ";", "MachineInstr", "*", "NewCmp", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_cmpgtui", ")", ",", "LoopEnd", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "1", ")", ";", "unsigned", "NewLoopCount", "=", "createVR", "(", "MF", ",", "MVT", "::", "i32", ")", ";", "MachineInstr", "*", "NewAdd", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "NewLoopCount", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "-", "1", ")", ";", "const", "auto", "&", "HRI", "=", "*", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "PrevInsts", ".", "begin", "(", ")", ",", "E", "=", "PrevInsts", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "substituteRegister", "(", "LoopCount", ",", "NewLoopCount", ",", "0", ",", "HRI", ")", ";", "PrevInsts", ".", "clear", "(", ")", ";", "PrevInsts", ".", "push_back", "(", "NewCmp", ")", ";", "PrevInsts", ".", "push_back", "(", "NewAdd", ")", ";", "if", "(", "Iter", "==", "MaxIter", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "J2_loop0r", ")", ")", ".", "addMBB", "(", "Loop", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ".", "addReg", "(", "NewLoopCount", ")", ";", "if", "(", "Iter", "==", "0", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Hexagon", "::", "J2_jumpf", ")", ")", ";", "Cond", ".", "push_back", "(", "NewCmp", "->", "getOperand", "(", "0", ")", ")", ";", "return", "NewLoopCount", ";", "}", "</s>" ]

[ "Generate", "code", "to", "reduce", "the", "loop", "iteration", "by", "one", "and", "check", "if", "the", "loop", "is", "finished", "." ]

[ "Hexagon", "Hexagon", "\"Expecting a hardware loop\"", "8", "0", "0", "Hexagon::J2_loop0i", "Hexagon::J2_loop1i", "1", "1", "1", "1", "1", "Hexagon::J2_loop0r", "\"Unexpected instruction\"", "1", "MVT::i1", "Hexagon::C2_cmpgtui", "1", "MVT::i32", "Hexagon::A2_addi", "1", "Hexagon", "0", "Hexagon::J2_loop0r", "0", "0", "Hexagon::J2_jumpf", "0" ]

[]

[ "<s>", "MCSymbol", "*", "X86AsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetKnownWindowsMSVC", "(", ")", ")", "{", "const", "MachineConstantPoolEntry", "&", "CPE", "=", "MF", "->", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", "[", "CPID", "]", ";", "if", "(", "!", "CPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "{", "SectionKind", "Kind", "=", "CPE", ".", "getSectionKind", "(", "TM", ".", "getDataLayout", "(", ")", ")", ";", "const", "Constant", "*", "C", "=", "CPE", ".", "Val", ".", "ConstVal", ";", "if", "(", "const", "MCSectionCOFF", "*", "S", "=", "dyn_cast", "<", "MCSectionCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForConstant", "(", "Kind", ",", "C", ")", ")", ")", "{", "if", "(", "MCSymbol", "*", "Sym", "=", "S", "->", "getCOMDATSymbol", "(", ")", ")", "{", "if", "(", "Sym", "->", "isUndefined", "(", ")", ")", "OutStreamer", ".", "EmitSymbolAttribute", "(", "Sym", ",", "MCSA_Global", ")", ";", "return", "Sym", ";", "}", "}", "}", "}", "return", "AsmPrinter", "::", "GetCPISymbol", "(", "CPID", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getNumMemOps", "(", "const", "IntrinsicInst", "*", "I", ")", "const", "{", "MemOp", "MOp", ";", "unsigned", "DstAddrSpace", "=", "~", "0u", ";", "unsigned", "SrcAddrSpace", "=", "~", "0u", ";", "const", "Function", "*", "F", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "const", "auto", "*", "MC", "=", "dyn_cast", "<", "MemTransferInst", ">", "(", "I", ")", ")", "{", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "MC", "->", "getLength", "(", ")", ")", ";", "if", "(", "!", "C", ")", "return", "-", "1", ";", "const", "unsigned", "Size", "=", "C", "->", "getValue", "(", ")", ".", "getZExtValue", "(", ")", ";", "const", "Align", "DstAlign", "=", "*", "MC", "->", "getDestAlign", "(", ")", ";", "const", "Align", "SrcAlign", "=", "*", "MC", "->", "getSourceAlign", "(", ")", ";", "MOp", "=", "MemOp", "::", "Copy", "(", "Size", ",", "false", ",", "DstAlign", ",", "SrcAlign", ",", "false", ",", "false", ")", ";", "DstAddrSpace", "=", "MC", "->", "getDestAddressSpace", "(", ")", ";", "SrcAddrSpace", "=", "MC", "->", "getSourceAddressSpace", "(", ")", ";", "}", "else", "if", "(", "const", "auto", "*", "MS", "=", "dyn_cast", "<", "MemSetInst", ">", "(", "I", ")", ")", "{", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "MS", "->", "getLength", "(", ")", ")", ";", "if", "(", "!", "C", ")", "return", "-", "1", ";", "const", "unsigned", "Size", "=", "C", "->", "getValue", "(", ")", ".", "getZExtValue", "(", ")", ";", "const", "Align", "DstAlign", "=", "*", "MS", "->", "getDestAlign", "(", ")", ";", "MOp", "=", "MemOp", "::", "Set", "(", "Size", ",", "false", ",", "DstAlign", ",", "false", ",", "false", ")", ";", "DstAddrSpace", "=", "MS", "->", "getDestAddressSpace", "(", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Expected a memcpy/move or memset!\"", ")", ";", "unsigned", "Limit", ",", "Factor", "=", "2", ";", "switch", "(", "I", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "memcpy", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemcpy", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "break", ";", "case", "Intrinsic", "::", "memmove", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemmove", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "break", ";", "case", "Intrinsic", "::", "memset", ":", "Limit", "=", "TLI", "->", "getMaxStoresPerMemset", "(", "F", "->", "hasMinSize", "(", ")", ")", ";", "Factor", "=", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Expected a memcpy/move or memset!\"", ")", ";", "}", "std", "::", "vector", "<", "EVT", ">", "MemOps", ";", "if", "(", "getTLI", "(", ")", "->", "findOptimalMemOpLowering", "(", "MemOps", ",", "Limit", ",", "MOp", ",", "DstAddrSpace", ",", "SrcAddrSpace", ",", "F", "->", "getAttributes", "(", ")", ")", ")", "return", "MemOps", ".", "size", "(", ")", "*", "Factor", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Given", "a", "memcpy/memset/memmove", "instruction", ",", "return", "the", "number", "of", "memory", "operations", "performed", ",", "via", "querying", "findOptimalMemOpLowering", "." ]

[ "ARM", "ARM", "0u", "0u", "1", "1", "\"Expected a memcpy/move or memset!\"", "2", "Intrinsic::memcpy", "Intrinsic::memmove", "Intrinsic::memset", "1", "\"Expected a memcpy/move or memset!\"", "1" ]

[]

[ "<s>", "static", "int", "untangle_mova", "(", "int", "*", "num_mova", ",", "rtx_insn", "*", "*", "first_mova", ",", "rtx_insn", "*", "new_mova", ")", "{", "int", "n_addr", "=", "0", ";", "int", "f_target", ",", "n_target", "=", "0", ";", "if", "(", "optimize", ")", "{", "if", "(", "INSN_ADDRESSES_SIZE", "(", ")", "<=", "(", "unsigned", ")", "INSN_UID", "(", "new_mova", ")", ")", "return", "-", "1", ";", "n_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "new_mova", ")", ")", ";", "n_target", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "XEXP", "(", "MOVA_LABELREF", "(", "new_mova", ")", ",", "0", ")", ")", ")", ";", "if", "(", "n_addr", ">", "n_target", "||", "n_addr", "+", "1022", "<", "n_target", ")", "{", "fixup_mova", "(", "new_mova", ")", ";", "return", "1", ";", "}", "}", "if", "(", "!", "(", "*", "num_mova", ")", "++", ")", "{", "*", "first_mova", "=", "new_mova", ";", "return", "2", ";", "}", "if", "(", "!", "optimize", "||", "(", "(", "f_target", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "XEXP", "(", "MOVA_LABELREF", "(", "*", "first_mova", ")", ",", "0", ")", ")", ")", ")", ">=", "n_target", ")", ")", "return", "-", "1", ";", "(", "*", "num_mova", ")", "--", ";", "if", "(", "f_target", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "*", "first_mova", ")", ")", ">", "n_target", "-", "n_addr", ")", "{", "fixup_mova", "(", "*", "first_mova", ")", ";", "return", "0", ";", "}", "else", "{", "fixup_mova", "(", "new_mova", ")", ";", "return", "1", ";", "}", "}", "</s>" ]

[ "NEW_MOVA", "is", "a", "mova", "we", "'ve", "just", "encountered", "while", "scanning", "forward", ".", "Update", "*", "num_mova", ",", "and", "check", "if", "the", "new", "mova", "is", "not", "nested", "within", "the", "first", "one", ".", "return", "0", "if", "*", "first_mova", "was", "replaced", ",", "1", "if", "new_mova", "was", "replaced", ",", "2", "if", "new_mova", "has", "been", "assigned", "to", "*", "first_mova", ",", "-1", "otherwise", ".." ]

[ "sh", "0", "0", "1", "0", "1022", "1", "2", "0", "1", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80old DAG->DAG Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Z80old", "\"Z80old DAG->DAG Instruction Selection\"" ]

[]

[ "<s>", "bool", "mips_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "!", "mips_mode_ok_for_mov_fmt_p", "(", "mode1", ")", "&&", "!", "mips_mode_ok_for_mov_fmt_p", "(", "mode2", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "HexagonConstEvaluator", "::", "evaluate", "(", "const", "MachineInstr", "&", "BrI", ",", "const", "CellMap", "&", "Inputs", ",", "SetVector", "<", "const", "MachineBasicBlock", "*", ">", "&", "Targets", ",", "bool", "&", "FallsThru", ")", "{", "unsigned", "Opc", "=", "BrI", ".", "getOpcode", "(", ")", ";", "bool", "SimpleBranch", "=", "false", ";", "bool", "Negated", "=", "false", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "J2_jumpf", ":", "case", "Hexagon", "::", "J2_jumpfnew", ":", "case", "Hexagon", "::", "J2_jumpfnewpt", ":", "Negated", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Hexagon", "::", "J2_jumpt", ":", "case", "Hexagon", "::", "J2_jumptnew", ":", "case", "Hexagon", "::", "J2_jumptnewpt", ":", "SimpleBranch", "=", "true", ";", "break", ";", "case", "Hexagon", "::", "J2_jump", ":", "Targets", ".", "insert", "(", "BrI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "FallsThru", "=", "false", ";", "return", "true", ";", "default", ":", "Undetermined", ":", "FallsThru", "=", "!", "BrI", ".", "isUnconditionalBranch", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SimpleBranch", ")", "{", "const", "MachineOperand", "&", "MD", "=", "BrI", ".", "getOperand", "(", "0", ")", ";", "RegisterSubReg", "PR", "(", "MD", ")", ";", "if", "(", "PR", ".", "SubReg", ")", "goto", "Undetermined", ";", "assert", "(", "Inputs", ".", "has", "(", "PR", ".", "Reg", ")", ")", ";", "const", "LatticeCell", "&", "PredC", "=", "Inputs", ".", "get", "(", "PR", ".", "Reg", ")", ";", "if", "(", "PredC", ".", "isBottom", "(", ")", ")", "goto", "Undetermined", ";", "uint32_t", "Props", "=", "PredC", ".", "properties", "(", ")", ";", "bool", "CTrue", "=", "false", ",", "CFalse", "=", "false", ";", "if", "(", "Props", "&", "ConstantProperties", "::", "Zero", ")", "CFalse", "=", "true", ";", "else", "if", "(", "Props", "&", "ConstantProperties", "::", "NonZero", ")", "CTrue", "=", "true", ";", "if", "(", "!", "CTrue", "&&", "!", "CFalse", ")", "goto", "Undetermined", ";", "const", "MachineBasicBlock", "*", "BranchTarget", "=", "BrI", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "FallsThru", "=", "false", ";", "if", "(", "(", "!", "Negated", "&&", "CTrue", ")", "||", "(", "Negated", "&&", "CFalse", ")", ")", "Targets", ".", "insert", "(", "BranchTarget", ")", ";", "else", "if", "(", "(", "!", "Negated", "&&", "CFalse", ")", "||", "(", "Negated", "&&", "CTrue", ")", ")", "FallsThru", "=", "true", ";", "else", "goto", "Undetermined", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "evaluate", "-", "Evaluate", "Expr", "and", "append", "the", "resulting", "set", "to", "Elts", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_jumpf", "Hexagon::J2_jumpfnew", "Hexagon::J2_jumpfnewpt", "Hexagon::J2_jumpt", "Hexagon::J2_jumptnew", "Hexagon::J2_jumptnewpt", "Hexagon::J2_jump", "0", "0", "1" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "ECLair" ]

[]

[ "<s>", "void", "ARM64TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this\"", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i128", "&&", "\"unexpected illegal conversion\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM64", "ARM64", "\"Don't know how to custom expand this\"", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "0", "MVT::i128", "\"unexpected illegal conversion\"" ]

[]

[ "<s>", "static", "char", "*", "detect_caches_linux", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "const", "char", "*", "platform", ";", "platform", "=", "elf_platform", "(", ")", ";", "if", "(", "platform", "!=", "NULL", ")", "{", "l1_line", "=", "128", ";", "if", "(", "platform", "[", "5", "]", "==", "'6'", ")", "l1_sizekb", "=", "64", ";", "else", "l1_sizekb", "=", "32", ";", "}", "else", "{", "l1_line", "=", "elf_dcachebsize", "(", ")", ";", "l1_sizekb", "=", "32", ";", "}", "l1_assoc", "=", "0", ";", "l2_sizekb", "=", "512", ";", "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "on", "Linux", "." ]

[ "rs6000", "128", "5", "64", "32", "32", "0", "512" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "false", ";", "if", "(", "Imm", ".", "isNegZero", "(", ")", ")", "return", "false", ";", "return", "Imm", ".", "isZero", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "Mips", "Mips", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "insert", "(", "RegisterRef", "RR", ")", "{", "if", "(", "PhysicalRegisterInfo", "::", "isRegMaskId", "(", "RR", ".", "Reg", ")", ")", "{", "const", "uint32_t", "*", "MB", "=", "PRI", ".", "getRegMaskBits", "(", "RR", ".", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "PRI", ".", "getTRI", "(", ")", ".", "getNumRegs", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MB", "[", "i", "/", "32", "]", "&", "(", "1u", "<<", "(", "i", "%", "32", ")", ")", ")", "continue", ";", "insert", "(", "RegisterRef", "(", "i", ",", "LaneBitmask", "::", "getAll", "(", ")", ")", ")", ";", "}", "return", "*", "this", ";", "}", "RegisterRef", "NR", "=", "PRI", ".", "normalize", "(", "RR", ")", ";", "auto", "F", "=", "Masks", ".", "find", "(", "NR", ".", "Reg", ")", ";", "if", "(", "F", "==", "Masks", ".", "end", "(", ")", ")", "Masks", ".", "insert", "(", "{", "NR", ".", "Reg", ",", "NR", ".", "Mask", "}", ")", ";", "else", "F", "->", "second", "|=", "NR", ".", "Mask", ";", "if", "(", "PRI", ".", "hasPartialOverlaps", "(", "NR", ".", "Reg", ")", ")", "{", "for", "(", "MCRegUnitMaskIterator", "U", "(", "RR", ".", "Reg", ",", "&", "PRI", ".", "getTRI", "(", ")", ")", ";", "U", ".", "isValid", "(", ")", ";", "++", "U", ")", "{", "std", "::", "pair", "<", "RegisterId", ",", "LaneBitmask", ">", "P", "=", "*", "U", ";", "if", "(", "P", ".", "second", ".", "none", "(", ")", "||", "(", "P", ".", "second", "&", "RR", ".", "Mask", ")", ".", "none", "(", ")", ")", "continue", ";", "ExpUnits", ".", "set", "(", "P", ".", "first", ")", ";", "CheckUnits", "=", "true", ";", "}", "}", "return", "*", "this", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon", "1", "32", "1u", "32" ]

[]

[ "<s>", "Expected", "<", "uint64_t", ">", "FunctionSym", "::", "getAddress", "(", "const", "HSACodeObject", "*", "CodeObject", ",", "const", "object", "::", "ELF64LEObjectFile", "::", "Elf_Shdr", "*", "Text", ")", "const", "{", "assert", "(", "Text", ")", ";", "auto", "ElfHeader", "=", "CodeObject", "->", "getELFFile", "(", ")", ".", "getHeader", "(", ")", ";", "if", "(", "ElfHeader", ".", "e_type", "==", "ELF", "::", "ET_REL", ")", "{", "return", "st_value", "+", "Text", "->", "sh_addr", ";", "}", "return", "st_value", ";", "}", "</s>" ]

[ "Returns", "the", "address", "of", "this", "pointer", "in", "this", "block", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "basic_block", "add_condition_to_bb", "(", "tree", "function_decl", ",", "tree", "version_decl", ",", "tree", "predicate_chain", ",", "basic_block", "new_bb", ")", "{", "gimple", "return_stmt", ";", "tree", "convert_expr", ",", "result_var", ";", "gimple", "convert_stmt", ";", "gimple", "call_cond_stmt", ";", "gimple", "if_else_stmt", ";", "basic_block", "bb1", ",", "bb2", ",", "bb3", ";", "edge", "e12", ",", "e23", ";", "tree", "cond_var", ",", "and_expr_var", "=", "NULL_TREE", ";", "gimple_seq", "gseq", ";", "tree", "predicate_decl", ",", "predicate_arg", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "function_decl", ")", ")", ";", "gcc_assert", "(", "new_bb", "!=", "NULL", ")", ";", "gseq", "=", "bb_seq", "(", "new_bb", ")", ";", "convert_expr", "=", "build1", "(", "CONVERT_EXPR", ",", "ptr_type_node", ",", "build_fold_addr_expr", "(", "version_decl", ")", ")", ";", "result_var", "=", "create_tmp_var", "(", "ptr_type_node", ")", ";", "convert_stmt", "=", "gimple_build_assign", "(", "result_var", ",", "convert_expr", ")", ";", "return_stmt", "=", "gimple_build_return", "(", "result_var", ")", ";", "if", "(", "predicate_chain", "==", "NULL_TREE", ")", "{", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "convert_stmt", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "return_stmt", ")", ";", "set_bb_seq", "(", "new_bb", ",", "gseq", ")", ";", "gimple_set_bb", "(", "convert_stmt", ",", "new_bb", ")", ";", "gimple_set_bb", "(", "return_stmt", ",", "new_bb", ")", ";", "pop_cfun", "(", ")", ";", "return", "new_bb", ";", "}", "while", "(", "predicate_chain", "!=", "NULL", ")", "{", "cond_var", "=", "create_tmp_var", "(", "integer_type_node", ")", ";", "predicate_decl", "=", "TREE_PURPOSE", "(", "predicate_chain", ")", ";", "predicate_arg", "=", "TREE_VALUE", "(", "predicate_chain", ")", ";", "call_cond_stmt", "=", "gimple_build_call", "(", "predicate_decl", ",", "1", ",", "predicate_arg", ")", ";", "gimple_call_set_lhs", "(", "call_cond_stmt", ",", "cond_var", ")", ";", "gimple_set_block", "(", "call_cond_stmt", ",", "DECL_INITIAL", "(", "function_decl", ")", ")", ";", "gimple_set_bb", "(", "call_cond_stmt", ",", "new_bb", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "call_cond_stmt", ")", ";", "predicate_chain", "=", "TREE_CHAIN", "(", "predicate_chain", ")", ";", "if", "(", "and_expr_var", "==", "NULL", ")", "and_expr_var", "=", "cond_var", ";", "else", "{", "gimple", "assign_stmt", ";", "assign_stmt", "=", "gimple_build_assign", "(", "and_expr_var", ",", "build2", "(", "MIN_EXPR", ",", "integer_type_node", ",", "cond_var", ",", "and_expr_var", ")", ")", ";", "gimple_set_block", "(", "assign_stmt", ",", "DECL_INITIAL", "(", "function_decl", ")", ")", ";", "gimple_set_bb", "(", "assign_stmt", ",", "new_bb", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "assign_stmt", ")", ";", "}", "}", "if_else_stmt", "=", "gimple_build_cond", "(", "GT_EXPR", ",", "and_expr_var", ",", "integer_zero_node", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "gimple_set_block", "(", "if_else_stmt", ",", "DECL_INITIAL", "(", "function_decl", ")", ")", ";", "gimple_set_bb", "(", "if_else_stmt", ",", "new_bb", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "if_else_stmt", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "convert_stmt", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "return_stmt", ")", ";", "set_bb_seq", "(", "new_bb", ",", "gseq", ")", ";", "bb1", "=", "new_bb", ";", "e12", "=", "split_block", "(", "bb1", ",", "if_else_stmt", ")", ";", "bb2", "=", "e12", "->", "dest", ";", "e12", "->", "flags", "&=", "~", "EDGE_FALLTHRU", ";", "e12", "->", "flags", "|=", "EDGE_TRUE_VALUE", ";", "e23", "=", "split_block", "(", "bb2", ",", "return_stmt", ")", ";", "gimple_set_bb", "(", "convert_stmt", ",", "bb2", ")", ";", "gimple_set_bb", "(", "return_stmt", ",", "bb2", ")", ";", "bb3", "=", "e23", "->", "dest", ";", "make_edge", "(", "bb1", ",", "bb3", ",", "EDGE_FALSE_VALUE", ")", ";", "remove_edge", "(", "e23", ")", ";", "make_edge", "(", "bb2", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ",", "0", ")", ";", "pop_cfun", "(", ")", ";", "return", "bb3", ";", "}", "</s>" ]

[ "This", "adds", "a", "condition", "to", "the", "basic_block", "NEW_BB", "in", "function", "FUNCTION_DECL", "to", "return", "a", "pointer", "to", "VERSION_DECL", "if", "we", "are", "running", "on", "a", "machine", "that", "supports", "the", "index", "CLONE_ISA", "hardware", "architecture", "bits", ".", "This", "function", "will", "be", "called", "during", "version", "dispatch", "to", "decide", "which", "function", "version", "to", "execute", ".", "It", "returns", "the", "basic", "block", "at", "the", "end", ",", "to", "which", "more", "conditions", "can", "be", "added", "." ]

[ "i386", "1", "0" ]

[]

[ "<s>", "virtual", "const", "TargetSubtargetInfo", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Teak" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "Fast", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "!", "IsMemset", "&&", "Size", ">=", "16", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoImplicitFloat", ")", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f128", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "f128", ";", "return", "Size", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "16", "16", "MVT::f128", "0", "1", "MVT::f128", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "EVT", "VT", "=", "getValueType", "(", "DL", ",", "Ty", ",", "true", ")", ";", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "VT", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "isLegalT1ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "isLegalT2ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "1", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "1", ")", ";", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i64", ":", "if", "(", "Scale", "==", "1", "||", "(", "AM", ".", "HasBaseReg", "&&", "Scale", "==", "-", "1", ")", ")", "return", "true", ";", "if", "(", "!", "AM", ".", "HasBaseReg", "&&", "Scale", "==", "2", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "Scale", "&", "1", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "Scale", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM", "0", "MVT::i1", "MVT::i8", "MVT::i32", "0", "1", "1", "MVT::i16", "MVT::i64", "1", "1", "2", "MVT::isVoid", "1" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "lowerToVVP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "unsigned", "Opcode", "=", "Op", "->", "getOpcode", "(", ")", ";", "auto", "VVPOpcodeOpt", "=", "getVVPOpcode", "(", "Opcode", ")", ";", "if", "(", "!", "VVPOpcodeOpt", ".", "hasValue", "(", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "VVPOpcode", "=", "VVPOpcodeOpt", ".", "getValue", "(", ")", ";", "const", "bool", "FromVP", "=", "ISD", "::", "isVPOpcode", "(", "Opcode", ")", ";", "VECustomDAG", "CDAG", "(", "DAG", ",", "Op", ")", ";", "MVT", "MaskVT", "=", "MVT", "::", "v256i1", ";", "EVT", "OpVecVT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "LegalVecVT", "=", "getTypeToTransformTo", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "OpVecVT", ")", ";", "SDValue", "AVL", ";", "SDValue", "Mask", ";", "if", "(", "FromVP", ")", "{", "auto", "MaskIdx", "=", "ISD", "::", "getVPMaskIdx", "(", "Opcode", ")", ".", "getValue", "(", ")", ";", "auto", "AVLIdx", "=", "ISD", "::", "getVPExplicitVectorLengthIdx", "(", "Opcode", ")", ".", "getValue", "(", ")", ";", "Mask", "=", "Op", "->", "getOperand", "(", "MaskIdx", ")", ";", "AVL", "=", "Op", "->", "getOperand", "(", "AVLIdx", ")", ";", "}", "else", "{", "AVL", "=", "CDAG", ".", "getConstant", "(", "OpVecVT", ".", "getVectorNumElements", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "ConstTrue", "=", "CDAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i32", ")", ";", "Mask", "=", "CDAG", ".", "getBroadcast", "(", "MaskVT", ",", "ConstTrue", ",", "AVL", ")", ";", "}", "if", "(", "isVVPBinaryOp", "(", "VVPOpcode", ")", ")", "{", "assert", "(", "LegalVecVT", ".", "isSimple", "(", ")", ")", ";", "return", "CDAG", ".", "getNode", "(", "VVPOpcode", ",", "LegalVecVT", ",", "{", "Op", "->", "getOperand", "(", "0", ")", ",", "Op", "->", "getOperand", "(", "1", ")", ",", "Mask", ",", "AVL", "}", ")", ";", "}", "if", "(", "VVPOpcode", "==", "VEISD", "::", "VVP_SELECT", ")", "{", "auto", "Mask", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "auto", "OnTrue", "=", "Op", "->", "getOperand", "(", "1", ")", ";", "auto", "OnFalse", "=", "Op", "->", "getOperand", "(", "2", ")", ";", "return", "CDAG", ".", "getNode", "(", "VVPOpcode", ",", "LegalVecVT", ",", "{", "OnTrue", ",", "OnFalse", ",", "Mask", ",", "AVL", "}", ")", ";", "}", "llvm_unreachable", "(", "\"lowerToVVP called for unexpected SDNode.\"", ")", ";", "}", "</s>" ]

[ "}", "Custom", "Inserter" ]

[ "VE", "VE", "ISD::isVPOpcode", "VE", "MVT::v256i1", "ISD::getVPMaskIdx", "ISD::getVPExplicitVectorLengthIdx", "MVT::i32", "1", "MVT::i32", "0", "1", "VEISD::VVP_SELECT", "0", "1", "2", "\"lowerToVVP called for unexpected SDNode.\"" ]

[]

[ "<s>", "MCSymbol", "*", "DLXMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "int", "ix86_avx_u128_mode_after", "(", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "vzeroupper_operation", "(", "pat", ",", "VOIDmode", ")", "||", "vzeroall_operation", "(", "pat", ",", "VOIDmode", ")", ")", "return", "AVX_U128_CLEAN", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "bool", "avx_upper_reg_found", "=", "false", ";", "note_stores", "(", "pat", ",", "ix86_check_avx_upper_stores", ",", "&", "avx_upper_reg_found", ")", ";", "return", "avx_upper_reg_found", "?", "AVX_U128_DIRTY", ":", "AVX_U128_CLEAN", ";", "}", "return", "mode", ";", "}", "</s>" ]

[ "Calculate", "mode", "of", "upper", "128bit", "AVX", "registers", "after", "the", "insn", "." ]

[ "i386" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "Sparc" ]

[]

[ "<s>", "rtx", "rs6000_emit_fp_cror", "(", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "rtx", "cond", "[", "2", "]", ";", "int", "n", "=", "0", ";", "if", "(", "code", "==", "LTGT", "||", "code", "==", "LE", "||", "code", "==", "UNLT", ")", "cond", "[", "n", "++", "]", "=", "gen_rtx_fmt_ee", "(", "LT", ",", "mode", ",", "x", ",", "const0_rtx", ")", ";", "if", "(", "code", "==", "LTGT", "||", "code", "==", "GE", "||", "code", "==", "UNGT", ")", "cond", "[", "n", "++", "]", "=", "gen_rtx_fmt_ee", "(", "GT", ",", "mode", ",", "x", ",", "const0_rtx", ")", ";", "if", "(", "code", "==", "LE", "||", "code", "==", "GE", "||", "code", "==", "UNEQ", ")", "cond", "[", "n", "++", "]", "=", "gen_rtx_fmt_ee", "(", "EQ", ",", "mode", ",", "x", ",", "const0_rtx", ")", ";", "if", "(", "code", "==", "UNLT", "||", "code", "==", "UNGT", "||", "code", "==", "UNEQ", ")", "cond", "[", "n", "++", "]", "=", "gen_rtx_fmt_ee", "(", "UNORDERED", ",", "mode", ",", "x", ",", "const0_rtx", ")", ";", "gcc_assert", "(", "n", "==", "2", ")", ";", "rtx", "cc", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "rtx", "logical", "=", "gen_rtx_IOR", "(", "mode", ",", "cond", "[", "0", "]", ",", "cond", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_cceq_ior_compare", "(", "mode", ",", "cc", ",", "logical", ",", "cond", "[", "0", "]", ",", "x", ",", "cond", "[", "1", "]", ",", "x", ")", ")", ";", "return", "cc", ";", "}", "</s>" ]

[ "Emit", "code", "doing", "a", "cror", "of", "two", "CR", "bits", ",", "for", "FP", "comparisons", "with", "a", "CODE", "that", "requires", "this", ".", "The", "result", "is", "mode", "MODE", "." ]

[ "rs6000", "2", "0", "2", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "rtx", "msp430_get_inner_dest_code", "(", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "rtx", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "case", "CONST", ":", "case", "LABEL_REF", ":", "return", "x", ";", "case", "MEM", ":", "switch", "(", "GET_CODE", "(", "op0", ")", ")", "{", "case", "REG", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "case", "POST_INC", ":", "return", "x", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "op0", ",", "0", ")", ")", "==", "REG", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "==", "CONST", "||", "GET_CODE", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "return", "x", ";", "else", "return", "msp430_get_inner_dest_code", "(", "op0", ")", ";", "}", "return", "msp430_get_inner_dest_code", "(", "op0", ")", ";", "default", ":", "if", "(", "GET_RTX_FORMAT", "(", "code", ")", "[", "0", "]", "!=", "'e'", ")", "return", "x", ";", "return", "msp430_get_inner_dest_code", "(", "op0", ")", ";", "}", "break", ";", "default", ":", "if", "(", "op0", "==", "NULL_RTX", ")", "gcc_unreachable", "(", ")", ";", "else", "{", "if", "(", "GET_RTX_FORMAT", "(", "code", ")", "[", "0", "]", "!=", "'e'", "&&", "code", "!=", "ENTRY_VALUE", ")", "return", "x", ";", "return", "msp430_get_inner_dest_code", "(", "op0", ")", ";", "}", "}", "}", "</s>" ]

[ "Recurse", "within", "X", "to", "find", "the", "actual", "destination", "operand", "of", "the", "expression", ".", "For", "example", ":", "(", "plus", "(", "ashift", "(", "minus", "(", "ashift", "(", "reg", ")", "(", "const_int", ")", "......", "should", "return", "the", "reg", "RTX", "." ]

[ "msp430", "0", "0", "1", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680X0 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "M680x0", "\"M680X0 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "ExpandInlineAsm", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasV6Ops", "(", ")", ")", "return", "false", ";", "InlineAsm", "*", "IA", "=", "cast", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ";", "std", "::", "string", "AsmStr", "=", "IA", "->", "getAsmString", "(", ")", ";", "SmallVector", "<", "StringRef", ",", "4", ">", "AsmPieces", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\";\\n\"", ")", ";", "switch", "(", "AsmPieces", ".", "size", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "1", ":", "AsmStr", "=", "AsmPieces", "[", "0", "]", ";", "AsmPieces", ".", "clear", "(", ")", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\" \\t,\"", ")", ";", "if", "(", "AsmPieces", ".", "size", "(", ")", "==", "3", "&&", "AsmPieces", "[", "0", "]", "==", "\"rev\"", "&&", "AsmPieces", "[", "1", "]", "==", "\"$0\"", "&&", "AsmPieces", "[", "2", "]", "==", "\"$1\"", "&&", "IA", "->", "getConstraintString", "(", ")", ".", "compare", "(", "0", ",", "4", ",", "\"=l,l\"", ")", "==", "0", ")", "{", "const", "IntegerType", "*", "Ty", "=", "dyn_cast", "<", "IntegerType", ">", "(", "CI", "->", "getType", "(", ")", ")", ";", "if", "(", "Ty", "&&", "Ty", "->", "getBitWidth", "(", ")", "==", "32", ")", "return", "IntrinsicLowering", "::", "LowerToByteSwap", "(", "CI", ")", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "hook", "allows", "the", "target", "to", "expand", "an", "inline", "asm", "call", "to", "be", "explicit", "llvm", "code", "if", "it", "wants", "to", "." ]

[ "ARM", "ARM", "4", "\";\\n\"", "1", "0", "\" \\t,\"", "3", "0", "\"rev\"", "1", "\"$0\"", "2", "\"$1\"", "0", "4", "\"=l,l\"", "0", "32" ]

[]

[ "<s>", "void", "rs6000_split_lock_test_and_set", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "emit_insn", "(", "gen_isync", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "test", "and", "set", "operation", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "value", "set", ".", "SCRATCH", "is", "a", "scratch", "GPR", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "DecodeStatus", "SystemZDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "if", "(", "Bytes", "[", "0", "]", "<", "0x40", ")", "{", "Size", "=", "2", ";", "Table", "=", "DecoderTable16", ";", "}", "else", "if", "(", "Bytes", "[", "0", "]", "<", "0xc0", ")", "{", "Size", "=", "4", ";", "Table", "=", "DecoderTable32", ";", "}", "else", "{", "Size", "=", "6", ";", "Table", "=", "DecoderTable48", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "Size", ")", "{", "Size", "=", "Bytes", ".", "size", "(", ")", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint64_t", "Inst", "=", "0", ";", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "8", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "Table", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "SystemZ", "SystemZ", "0", "2", "0", "0x40", "2", "0", "0xc0", "4", "6", "0", "0", "8" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_parse_one_option_token", "(", "const", "char", "*", "token", ",", "size_t", "length", ",", "const", "struct", "aarch64_flag_desc", "*", "flag", ",", "const", "char", "*", "option_name", ")", "{", "for", "(", ";", "flag", "->", "name", "!=", "NULL", ";", "flag", "++", ")", "{", "if", "(", "length", "==", "strlen", "(", "flag", "->", "name", ")", "&&", "!", "strncmp", "(", "flag", "->", "name", ",", "token", ",", "length", ")", ")", "return", "flag", "->", "flag", ";", "}", "error", "(", "\"unknown flag passed in %<-moverride=%s%> (%s)\"", ",", "option_name", ",", "token", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Parse", "TOKEN", ",", "which", "has", "length", "LENGTH", "to", "see", "if", "it", "is", "an", "option", "described", "in", "FLAG", ".", "If", "it", "is", ",", "return", "the", "index", "bit", "for", "that", "fusion", "type", ".", "If", "not", ",", "error", "(", "printing", "OPTION_NAME", ")", "and", "return", "zero", "." ]

[ "aarch64", "\"unknown flag passed in %<-moverride=%s%> (%s)\"", "0" ]

[]

[ "<s>", "bool", "mn10300_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "cc_mode", ")", "{", "rtx", "op1", ",", "flags", ";", "machine_mode", "flags_mode", ";", "gcc_checking_assert", "(", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", "==", "2", ")", ";", "op1", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "op1", ")", ")", "==", "COMPARE", ")", ";", "flags", "=", "SET_DEST", "(", "op1", ")", ";", "flags_mode", "=", "GET_MODE", "(", "flags", ")", ";", "if", "(", "GET_MODE", "(", "SET_SRC", "(", "op1", ")", ")", "!=", "flags_mode", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "flags_mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "cc_flags_for_mode", "(", "flags_mode", ")", "&", "~", "cc_flags_for_mode", "(", "cc_mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "helper", "function", "for", "matching", "parallels", "that", "set", "the", "flags", "." ]

[ "mn10300", "0", "2", "0", "1" ]

[]

[ "<s>", "bool", "function_resolver", "::", "require_vector_type", "(", "unsigned", "int", "argno", ",", "vector_type_index", "type", ")", "{", "tree", "expected", "=", "acle_vector_types", "[", "0", "]", "[", "type", "]", ";", "tree", "actual", "=", "get_argument_type", "(", "argno", ")", ";", "if", "(", "!", "matches_type_p", "(", "expected", ",", "actual", ")", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects %qT\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "expected", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "have", "vector", "type", "TYPE", ",", "in", "cases", "where", "this", "requirement", "holds", "for", "all", "uses", "of", "the", "function", ".", "Return", "true", "if", "the", "argument", "has", "the", "right", "form", ",", "otherwise", "report", "an", "appropriate", "error", "." ]

[ "aarch64", "0", "\"passing %qT to argument %d of %qE, which\"", "\" expects %qT\"", "1" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "getPPCSubtarget", "(", ")", ".", "hasISEL", "(", ")", ")", "{", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "Nest", ")", "||", "VRegs", "[", "Idx", "]", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", "[", "0", "]", ",", "Regs", ")", ";", "}", ")", ")", "return", "false", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "CC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "X86", "X86", "8", "0", "1", "0", "X86" ]

[]

[ "<s>", "static", "bool", "cr16_class_likely_spilled_p", "(", "reg_class_t", "rclass", ")", "{", "if", "(", "(", "rclass", ")", "==", "SHORT_REGS", "||", "(", "rclass", ")", "==", "DOUBLE_BASE_REGS", "||", "(", "rclass", ")", "==", "LONG_REGS", "||", "(", "rclass", ")", "==", "GENERAL_REGS", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CLASS_LIKELY_SPILLED_P", "." ]

[ "cr16" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "if", "(", "EnableSIInsertWaitcntsPass", ")", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "else", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "const", "MINA32RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "MINA32", "MINA32" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "resolveFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "Done", "=", "rewriteFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "M68k" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "RC", "->", "hasType", "(", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "RC", "->", "hasType", "(", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "0", "MVT::i8", "AVR::STDPtrQRr", "MVT::i16", "AVR::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "bool", "riscv_split_symbol", "(", "rtx", "temp", ",", "rtx", "addr", ",", "machine_mode", "mode", ",", "rtx", "*", "low_out", ",", "bool", "in_splitter", ")", "{", "enum", "riscv_symbol_type", "symbol_type", ";", "if", "(", "(", "GET_CODE", "(", "addr", ")", "==", "HIGH", "&&", "mode", "==", "MAX_MACHINE_MODE", ")", "||", "!", "riscv_symbolic_constant_p", "(", "addr", ",", "&", "symbol_type", ")", "||", "riscv_symbol_insns", "(", "symbol_type", ")", "==", "0", "||", "!", "riscv_split_symbol_type", "(", "symbol_type", ")", ")", "return", "false", ";", "if", "(", "low_out", ")", "switch", "(", "symbol_type", ")", "{", "case", "SYMBOL_ABSOLUTE", ":", "{", "rtx", "high", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "addr", ")", ")", ";", "high", "=", "riscv_force_temporary", "(", "temp", ",", "high", ",", "in_splitter", ")", ";", "*", "low_out", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "high", ",", "addr", ")", ";", "}", "break", ";", "case", "SYMBOL_PCREL", ":", "{", "static", "unsigned", "seqno", ";", "char", "buf", "[", "32", "]", ";", "rtx", "label", ";", "ssize_t", "bytes", "=", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\".LA%u\"", ",", "seqno", ")", ";", "gcc_assert", "(", "(", "size_t", ")", "bytes", "<", "sizeof", "(", "buf", ")", ")", ";", "label", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "buf", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "label", ")", "|=", "SYMBOL_FLAG_LOCAL", ";", "if", "(", "!", "nonzero_address_p", "(", "addr", ")", ")", "SYMBOL_REF_WEAK", "(", "label", ")", "=", "1", ";", "if", "(", "temp", "==", "NULL", ")", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_auipcdi", "(", "temp", ",", "copy_rtx", "(", "addr", ")", ",", "GEN_INT", "(", "seqno", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_auipcsi", "(", "temp", ",", "copy_rtx", "(", "addr", ")", ",", "GEN_INT", "(", "seqno", ")", ")", ")", ";", "*", "low_out", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "temp", ",", "label", ")", ";", "seqno", "++", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "If", "MODE", "is", "MAX_MACHINE_MODE", ",", "ADDR", "appears", "as", "a", "move", "operand", ",", "otherwise", "it", "appears", "in", "a", "MEM", "of", "that", "mode", ".", "Return", "true", "if", "ADDR", "is", "a", "legitimate", "constant", "in", "that", "context", "and", "can", "be", "split", "into", "high", "and", "low", "parts", ".", "If", "so", ",", "and", "if", "LOW_OUT", "is", "nonnull", ",", "emit", "the", "high", "part", "and", "store", "the", "low", "part", "in", "*", "LOW_OUT", ".", "Leave", "*", "LOW_OUT", "unchanged", "otherwise", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", "and", "is", "used", "to", "load", "the", "high", "part", "into", "a", "register", ".", "When", "MODE", "is", "MAX_MACHINE_MODE", ",", "the", "low", "part", "is", "guaranteed", "to", "be", "a", "legitimize", "SET_SRC", "for", "an", ".md", "pattern", ",", "otherwise", "the", "low", "part", "is", "guaranteed", "to", "be", "a", "legitimate", "address", "for", "mode", "MODE", "." ]

[ "riscv", "0", "32", "\".LA%u\"", "1" ]

[]

[ "<s>", "Sched", "::", "Preference", "ARMTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "unsigned", "NumVals", "=", "N", "->", "getNumValues", "(", ")", ";", "if", "(", "!", "NumVals", ")", "return", "Sched", "::", "RegPressure", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumVals", ";", "++", "i", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "i", ")", ";", "if", "(", "VT", "==", "MVT", "::", "Glue", "||", "VT", "==", "MVT", "::", "Other", ")", "continue", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "||", "VT", ".", "isVector", "(", ")", ")", "return", "Sched", "::", "Latency", ";", "}", "if", "(", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "Sched", "::", "RegPressure", ";", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetInstrDesc", "&", "TID", "=", "TII", "->", "get", "(", "N", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "TID", ".", "getNumDefs", "(", ")", "==", "0", ")", "return", "Sched", "::", "RegPressure", ";", "if", "(", "!", "Itins", "->", "isEmpty", "(", ")", "&&", "Itins", "->", "getOperandCycle", "(", "TID", ".", "getSchedClass", "(", ")", ",", "0", ")", ">", "2", ")", "return", "Sched", "::", "Latency", ";", "return", "Sched", "::", "RegPressure", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "MVT::Glue", "MVT::Other", "0", "0", "2" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_load", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "tmp_reg", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "load_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "FLOAT_EXTEND", "||", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", ")", "{", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "load_string", "=", "\"lfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "load_string", "=", "\"lfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", "&&", "TARGET_P9_DFORM_SCALAR", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "load_string", "=", "\"lxssp\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "load_string", "=", "\"lxsd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "load_string", "=", "\"lbz\"", ";", "break", ";", "case", "HImode", ":", "load_string", "=", "\"lhz\"", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "load_string", "=", "\"lwz\"", ";", "break", ";", "case", "DImode", ":", "case", "DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "load_string", "=", "\"ld\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 load fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "load_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "load", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "rs6000", "0", "0", "\"emit_fusion_p9_load, bad reg #1\"", "\"lfs\"", "\"lfd\"", "\"lxssp\"", "\"lxsd\"", "\"lbz\"", "\"lhz\"", "\"lwz\"", "\"ld\"", "\"emit_fusion_p9_load, bad reg #2\"", "\"emit_fusion_p9_load not MEM\"", "0", "\"power9 load fusion\"", "\"\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "LanaiRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "int", "arm_debugger_arg_offset", "(", "int", "value", ",", "rtx", "addr", ")", "{", "rtx", "insn", ";", "if", "(", "value", "!=", "0", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "addr", ")", "==", "(", "unsigned", ")", "HARD_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "if", "(", "(", "TARGET_THUMB", "||", "!", "frame_pointer_needed", ")", "&&", "REGNO", "(", "addr", ")", "==", "SP_REGNUM", ")", "return", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "REGNO", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ")", "==", "REGNO", "(", "addr", ")", "&&", "GET_CODE", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "0", ")", ")", "==", "(", "unsigned", ")", "HARD_FRAME_POINTER_REGNUM", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "value", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", ",", "1", ")", ")", ";", "break", ";", "}", "}", "if", "(", "value", "==", "0", ")", "{", "debug_rtx", "(", "addr", ")", ";", "warning", "(", "0", ",", "\"unable to compute real location of stacked parameter\"", ")", ";", "value", "=", "8", ";", "}", "return", "value", ";", "}", "</s>" ]

[ "Handle", "a", "special", "case", "when", "computing", "the", "offset", "of", "an", "argument", "from", "the", "frame", "pointer", "." ]

[ "arm", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "0", "1", "1", "1", "1", "0", "0", "\"unable to compute real location of stacked parameter\"", "8" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "const", "int", "FI", ",", "KnownBits", "&", "Known", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "TargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "FI", ",", "Known", ",", "MF", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "getSubtarget", "(", ")", "->", "getKnownHighZeroBitsForFrameIndex", "(", ")", ")", ";", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "of", "FrameIndex", "FIOp", "are", "known", "to", "be", "0", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "void", "AArch64MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "TLSDESCCALL", ")", "{", "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_tlsdesc_call", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "CompilerBarrier", "||", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "SPACE", "||", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "EH_SjLj_Setup", ")", "{", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Binary", ",", "support", "::", "little", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::TLSDESCCALL", "AArch64::fixup_aarch64_tlsdesc_call", "0", "0", "AArch64::CompilerBarrier", "AArch64::SPACE", "AArch64::EH_SjLj_Setup", "support::endian", "support::little" ]

[]

[ "<s>", "void", "J2InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "J2", "J2" ]

[]

[ "<s>", "void", "AArch64TargetELFStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ")", "{", "getStreamer", "(", ")", ".", "emitInst", "(", "Inst", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "virtual", "void", "initializePass", "(", ")", "override", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "R600" ]

[]

[ "<s>", "MBlazeTargetLowering", "::", "ConstraintType", "MBlazeTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "return", "C_RegisterClass", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "1", "0" ]

[]

[ "<s>", "OperandMatchResultTy", "MipsAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "SmallVector", "<", "std", "::", "unique_ptr", "<", "MCParsedAsmOperand", ">", ",", "1", ">", "Operands", ";", "OperandMatchResultTy", "ResTy", "=", "parseAnyRegister", "(", "Operands", ")", ";", "if", "(", "ResTy", "==", "MatchOperand_Success", ")", "{", "assert", "(", "Operands", ".", "size", "(", ")", "==", "1", ")", ";", "MipsOperand", "&", "Operand", "=", "static_cast", "<", "MipsOperand", "&", ">", "(", "*", "Operands", ".", "front", "(", ")", ")", ";", "StartLoc", "=", "Operand", ".", "getStartLoc", "(", ")", ";", "EndLoc", "=", "Operand", ".", "getEndLoc", "(", ")", ";", "RegNo", "=", "-", "1", ";", "if", "(", "Operand", ".", "isGPRAsmReg", "(", ")", ")", "{", "RegNo", "=", "isGP64bit", "(", ")", "?", "Operand", ".", "getGPR64Reg", "(", ")", ":", "Operand", ".", "getGPR32Reg", "(", ")", ";", "}", "else", "if", "(", "Operand", ".", "isCheriAsmReg", "(", ")", ")", "{", "RegNo", "=", "Operand", ".", "getCheriReg", "(", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Got non-GPR register in .cfi directive!\"", ")", ";", "}", "return", "(", "RegNo", "==", "(", "unsigned", ")", "-", "1", ")", "?", "MatchOperand_NoMatch", ":", "MatchOperand_Success", ";", "}", "assert", "(", "Operands", ".", "size", "(", ")", "==", "0", ")", ";", "return", "(", "RegNo", "==", "(", "unsigned", ")", "-", "1", ")", "?", "MatchOperand_NoMatch", ":", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "Mips", "Mips", "1", "1", "Mips", "Mips", "1", "\"Got non-GPR register in .cfi directive!\"", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "getMinPrefetchStride", "(", ")", "const", "override", "{", "return", "2048", ";", "}", "</s>" ]

[ "Some", "HW", "prefetchers", "can", "handle", "accesses", "up", "to", "a", "certain", "constant", "stride", "." ]

[ "SystemZ", "2048" ]

[]

[ "<s>", "static", "unsigned", "getNumInterleavedAccesses", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "{", "return", "(", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", "+", "127", ")", "/", "128", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "interleaved", "accesses", "that", "will", "be", "generated", "when", "lowering", "accesses", "of", "the", "given", "type", "." ]

[ "ARM", "127", "128" ]

[]

[ "<s>", "static", "tree", "ix86_handle_abi_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "METHOD_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "FIELD_DECL", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "if", "(", "is_attribute_p", "(", "\"ms_abi\"", ",", "name", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"sysv_abi\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"ms_abi and sysv_abi attributes are not compatible\"", ")", ";", "}", "return", "NULL_TREE", ";", "}", "else", "if", "(", "is_attribute_p", "(", "\"sysv_abi\"", ",", "name", ")", ")", "{", "if", "(", "lookup_attribute", "(", "\"ms_abi\"", ",", "TYPE_ATTRIBUTES", "(", "*", "node", ")", ")", ")", "{", "error", "(", "\"ms_abi and sysv_abi attributes are not compatible\"", ")", ";", "}", "return", "NULL_TREE", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "ms_abi", "''", "or", "``", "sysv", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "i386", "\"%qE attribute only applies to functions\"", "\"ms_abi\"", "\"sysv_abi\"", "\"ms_abi and sysv_abi attributes are not compatible\"", "\"sysv_abi\"", "\"ms_abi\"", "\"ms_abi and sysv_abi attributes are not compatible\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "CMPPDrri", ":", "case", "X86", "::", "CMPPSrri", ":", "case", "X86", "::", "VCMPPDrri", ":", "case", "X86", "::", "VCMPPSrri", ":", "case", "X86", "::", "VCMPPDYrri", ":", "case", "X86", "::", "VCMPPSYrri", ":", "{", "unsigned", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "&", "0x7", ";", "switch", "(", "Imm", ")", "{", "case", "0x00", ":", "case", "0x03", ":", "case", "0x04", ":", "case", "0x07", ":", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "1", ",", "2", ")", ";", "}", "return", "false", ";", "}", "default", ":", "bool", "IsIntrinOpcode", ";", "if", "(", "isFMA3", "(", "MI", ".", "getOpcode", "(", ")", ",", "IsIntrinOpcode", ")", ")", "return", "findFMA3CommutedOpIndices", "(", "MI", ",", "IsIntrinOpcode", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "X86", "X86", "X86::CMPPDrri", "X86::CMPPSrri", "X86::VCMPPDrri", "X86::VCMPPSrri", "X86::VCMPPDYrri", "X86::VCMPPSYrri", "3", "0x7", "0x00", "0x03", "0x04", "0x07", "1", "2" ]

[]

[ "<s>", "void", "AVRInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "OpNo", ">=", "MI", "->", "size", "(", ")", ")", "{", "O", "<<", "\"<unknown>\"", ";", "return", ";", "}", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "O", "<<", "'.'", ";", "if", "(", "Imm", ">=", "0", ")", "O", "<<", "'+'", ";", "O", "<<", "Imm", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"Unknown pcrel immediate operand\"", ")", ";", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "AVR", "AVR", "\"<unknown>\"", "0", "\"Unknown pcrel immediate operand\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "markPhysRegUsed", "(", "PhysReg", ")", ";", "IncomingValueHandler", "::", "assignValueToReg", "(", "ValVReg", ",", "PhysReg", ",", "VA", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPXi", ":", "AArch64", "::", "STRXui", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPDi", ":", "AArch64", "::", "STRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::STPXi", "AArch64::STRXui", "AArch64::STPDi", "AArch64::STRDui", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::SELECT" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "if", "(", "0", ")", "errs", "(", ")", "<<", "\"<MCFixup\"", "<<", "\" Offset:\"", "<<", "Fixup", ".", "getOffset", "(", ")", "<<", "\" Value:\"", "<<", "*", "(", "Fixup", ".", "getValue", "(", ")", ")", "<<", "\" Kind:\"", "<<", "Fixup", ".", "getKind", "(", ")", "<<", "\" val \"", "<<", "Value", "<<", "\">\\n\"", ";", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "return", ";", "}", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "*", "(", "uint16_t", "*", ")", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "BPF", "BPF", "0", "\"<MCFixup\"", "\" Offset:\"", "\" Value:\"", "\" Kind:\"", "\" val \"", "\">\\n\"", "0", "2", "8", "8" ]

[]

[ "<s>", "CCAssignFn", "*", "GBZ80TargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "return", "RetCC_GBZ80", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "GBZ80", "GB", "GB" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "int", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "ArgumentPopSize", "=", "0", ";", "if", "(", "RetOpcode", "==", "AArch64", "::", "TCRETURNdi", "||", "RetOpcode", "==", "AArch64", "::", "TCRETURNri", ")", "{", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "1", ")", ";", "ArgumentPopSize", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "}", "else", "{", "ArgumentPopSize", "=", "AFI", "->", "getArgumentStackToRestore", "(", ")", ";", "}", "NumBytes", "+=", "ArgumentPopSize", ";", "unsigned", "NumRestores", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "LastPopI", "=", "MBBI", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "if", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "{", "++", "NumRestores", ";", "--", "LastPopI", ";", "}", "while", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", "{", "++", "LastPopI", ";", "--", "NumRestores", ";", "}", "}", "NumBytes", "-=", "NumRestores", "*", "16", ";", "assert", "(", "NumBytes", ">=", "0", "&&", "\"Negative stack allocation size!?\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "!", "canUseRedZone", "(", "MF", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "NumBytes", ",", "TII", ")", ";", "return", ";", "}", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "FP", ",", "-", "(", "NumRestores", "-", "1", ")", "*", "16", ",", "TII", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "AArch64", "AArch64", "\"Can only insert epilog into returning blocks\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "0", "AArch64::TCRETURNdi", "AArch64::TCRETURNri", "1", "0", "16", "0", "\"Negative stack allocation size!?\"", "AArch64::SP", "AArch64::SP", "AArch64::SP", "AArch64::FP", "1", "16" ]

[]

[ "<s>", "void", "ix86_simd_clone_adjust", "(", "struct", "cgraph_node", "*", "node", ")", "{", "const", "char", "*", "str", "=", "NULL", ";", "if", "(", "!", "node", "->", "definition", ")", "return", ";", "gcc_assert", "(", "node", "->", "decl", "==", "cfun", "->", "decl", ")", ";", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "str", "=", "\"sse2\"", ";", "break", ";", "case", "'c'", ":", "if", "(", "TARGET_PREFER_AVX128", ")", "{", "if", "(", "!", "TARGET_AVX", ")", "str", "=", "\"avx,prefer-vector-width=256\"", ";", "else", "str", "=", "\"prefer-vector-width=256\"", ";", "}", "else", "if", "(", "!", "TARGET_AVX", ")", "str", "=", "\"avx\"", ";", "break", ";", "case", "'d'", ":", "if", "(", "TARGET_PREFER_AVX128", ")", "{", "if", "(", "!", "TARGET_AVX2", ")", "str", "=", "\"avx2,prefer-vector-width=256\"", ";", "else", "str", "=", "\"prefer-vector-width=256\"", ";", "}", "else", "if", "(", "!", "TARGET_AVX2", ")", "str", "=", "\"avx2\"", ";", "break", ";", "case", "'e'", ":", "if", "(", "TARGET_PREFER_AVX256", ")", "{", "if", "(", "!", "TARGET_AVX512F", ")", "str", "=", "\"avx512f,prefer-vector-width=512\"", ";", "else", "str", "=", "\"prefer-vector-width=512\"", ";", "}", "else", "if", "(", "!", "TARGET_AVX512F", ")", "str", "=", "\"avx512f\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "str", "==", "NULL", ")", "return", ";", "push_cfun", "(", "NULL", ")", ";", "tree", "args", "=", "build_tree_list", "(", "NULL_TREE", ",", "build_string", "(", "strlen", "(", "str", ")", ",", "str", ")", ")", ";", "bool", "ok", "=", "ix86_valid_target_attribute_p", "(", "node", "->", "decl", ",", "NULL", ",", "args", ",", "0", ")", ";", "gcc_assert", "(", "ok", ")", ";", "pop_cfun", "(", ")", ";", "ix86_reset_previous_fndecl", "(", ")", ";", "ix86_set_current_function", "(", "node", "->", "decl", ")", ";", "}", "</s>" ]

[ "Add", "target", "attribute", "to", "SIMD", "clone", "NODE", "if", "needed", "." ]

[ "i386", "\"sse2\"", "\"avx,prefer-vector-width=256\"", "\"prefer-vector-width=256\"", "\"avx\"", "\"avx2,prefer-vector-width=256\"", "\"prefer-vector-width=256\"", "\"avx2\"", "\"avx512f,prefer-vector-width=512\"", "\"prefer-vector-width=512\"", "\"avx512f\"", "0" ]

[]

[ "<s>", "LLT", "AArch64TargetLowering", "::", "getOptimalMemOpLLT", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "Op", ".", "isMemset", "(", ")", "&&", "Op", ".", "size", "(", ")", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "Align", "AlignCheck", ")", "{", "if", "(", "Op", ".", "isAligned", "(", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "Align", "(", "1", ")", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "Op", ".", "isMemset", "(", ")", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "Align", "(", "16", ")", ")", ")", "return", "LLT", "::", "vector", "(", "2", ",", "64", ")", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "Align", "(", "16", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "128", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "Align", "(", "8", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "Align", "(", "4", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "32", ")", ";", "return", "LLT", "(", ")", ";", "}", "</s>" ]

[ "LLT", "returning", "variant", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "2", "64", "MVT::f128", "16", "128", "8", "MVT::i64", "8", "64", "4", "MVT::i32", "4", "32" ]

[]

[ "<s>", "static", "tree", "rs6000_vector_type", "(", "const", "char", "*", "name", ",", "tree", "elt_type", ",", "unsigned", "num_elts", ")", "{", "tree", "result", "=", "build_vector_type", "(", "elt_type", ",", "num_elts", ")", ";", "result", "=", "build_variant_type_copy", "(", "result", ")", ";", "add_builtin_type", "(", "name", ",", "result", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Create", "a", "builtin", "vector", "type", "with", "a", "name", ".", "Taking", "care", "not", "to", "give", "the", "canonical", "type", "a", "name", "." ]

[ "rs6000" ]

[]

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

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "XCore", "XCore", "XCore::LDWFI", "0" ]

[]