Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "char", "*", "aarch64_output_simd_mov_immediate", "(", "rtx", "const_vector", ",", "machine_mode", "mode", ",", "unsigned", "width", ")", "{", "bool", "is_valid", ";", "static", "char", "templ", "[", "40", "]", ";", "const", "char", "*", "mnemonic", ";", "const", "char", "*", "shift_op", ";", "unsigned", "int", "lane_count", "=", "0", ";", "char", "element_char", ";", "struct", "simd_immediate_info", "info", "=", "{", "NULL_RTX", ",", "0", ",", "0", ",", "false", ",", "false", "}", ";", "is_valid", "=", "aarch64_simd_valid_immediate", "(", "const_vector", ",", "mode", ",", "false", ",", "&", "info", ")", ";", "gcc_assert", "(", "is_valid", ")", ";", "element_char", "=", "sizetochar", "(", "info", ".", "element_width", ")", ";", "lane_count", "=", "width", "/", "info", ".", "element_width", ";", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "{", "gcc_assert", "(", "info", ".", "shift", "==", "0", "&&", "!", "info", ".", "mvn", ")", ";", "if", "(", "aarch64_float_const_zero_rtx_p", "(", "info", ".", "value", ")", ")", "info", ".", "value", "=", "GEN_INT", "(", "0", ")", ";", "else", "{", "REAL_VALUE_TYPE", "r", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "info", ".", "value", ")", ";", "char", "float_buf", "[", "buf_size", "]", "=", "{", "'\\0'", "}", ";", "real_to_decimal_for_mode", "(", "float_buf", ",", "&", "r", ",", "buf_size", ",", "buf_size", ",", "1", ",", "mode", ")", ";", "if", "(", "lane_count", "==", "1", ")", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"fmov\\t%%d0, %s\"", ",", "float_buf", ")", ";", "else", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"fmov\\t%%0.%d%c, %s\"", ",", "lane_count", ",", "element_char", ",", "float_buf", ")", ";", "return", "templ", ";", "}", "}", "mnemonic", "=", "info", ".", "mvn", "?", "\"mvni\"", ":", "\"movi\"", ";", "shift_op", "=", "info", ".", "msl", "?", "\"msl\"", ":", "\"lsl\"", ";", "if", "(", "lane_count", "==", "1", ")", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"%s\\t%%d0, \"", "HOST_WIDE_INT_PRINT_HEX", ",", "mnemonic", ",", "UINTVAL", "(", "info", ".", "value", ")", ")", ";", "else", "if", "(", "info", ".", "shift", ")", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"%s\\t%%0.%d%c, \"", "HOST_WIDE_INT_PRINT_HEX", "\", %s %d\"", ",", "mnemonic", ",", "lane_count", ",", "element_char", ",", "UINTVAL", "(", "info", ".", "value", ")", ",", "shift_op", ",", "info", ".", "shift", ")", ";", "else", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"%s\\t%%0.%d%c, \"", "HOST_WIDE_INT_PRINT_HEX", ",", "mnemonic", ",", "lane_count", ",", "element_char", ",", "UINTVAL", "(", "info", ".", "value", ")", ")", ";", "return", "templ", ";", "}", "</s>" ]

[ "Returns", "the", "string", "with", "the", "instruction", "for", "AdvSIMD", "MOVI", ",", "MVNI", ",", "ORR", "or", "BIC", "immediate", "with", "a", "CONST_VECTOR", "of", "MODE", "and", "WIDTH", ".", "WHICH", "selects", "whether", "to", "output", "MOVI/MVNI", ",", "ORR", "or", "BIC", "immediate", "." ]

[ "aarch64", "40", "0", "0", "0", "0", "0", "1", "1", "\"fmov\\t%%d0, %s\"", "\"fmov\\t%%0.%d%c, %s\"", "\"mvni\"", "\"movi\"", "\"msl\"", "\"lsl\"", "1", "\"%s\\t%%d0, \"", "\"%s\\t%%0.%d%c, \"", "\", %s %d\"", "\"%s\\t%%0.%d%c, \"" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_compat_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "unsigned", "int", "align", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "mode", "!=", "TDmode", "&&", "mode", "!=", "TFmode", ")", "{", "if", "(", "!", "type", ")", "{", "if", "(", "!", "(", "TARGET_SSE", "&&", "SSE_REG_MODE_P", "(", "mode", ")", ")", ")", "align", "=", "PARM_BOUNDARY", ";", "}", "else", "{", "if", "(", "!", "ix86_compat_aligned_value_p", "(", "type", ")", ")", "align", "=", "PARM_BOUNDARY", ";", "}", "}", "if", "(", "align", ">", "BIGGEST_ALIGNMENT", ")", "align", "=", "BIGGEST_ALIGNMENT", ";", "return", "align", ";", "}", "</s>" ]

[ "Return", "the", "alignment", "boundary", "for", "MODE", "and", "TYPE", "with", "alignment", "ALIGN", ".", "XXX", ":", "This", "function", "is", "obsolete", "and", "is", "only", "used", "for", "checking", "psABI", "compatibility", "with", "previous", "versions", "of", "GCC", "." ]

[ "i386" ]

[]

[ "<s>", "void", "thumb_expand_prologue", "(", ")", "{", "HOST_WIDE_INT", "amount", "=", "(", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ")", ";", "unsigned", "long", "func_type", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "{", "error", "(", "\"interrupt Service Routines cannot be coded in Thumb mode\"", ")", ";", "return", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "amount", ")", "{", "amount", "=", "ROUND_UP", "(", "amount", ")", ";", "if", "(", "amount", "<", "512", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "else", "{", "int", "regno", ";", "rtx", "reg", ";", "for", "(", "regno", "=", "LAST_ARG_REGNUM", "+", "1", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", "&&", "!", "(", "TARGET_SINGLE_PIC_BASE", "&&", "(", "regno", "==", "arm_pic_register", ")", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "regno", "==", "THUMB_HARD_FRAME_POINTER_REGNUM", ")", ")", ")", "break", ";", "if", "(", "regno", ">", "LAST_LO_REGNUM", ")", "{", "rtx", "spare", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "IP_REGNUM", ")", ";", "reg", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "LAST_LO_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "spare", ",", "reg", ")", ")", ";", "emit_insn", "(", "gen_prologue_use", "(", "spare", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "reg", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "spare", ")", ")", ";", "emit_insn", "(", "gen_prologue_use", "(", "reg", ")", ")", ";", "}", "else", "{", "reg", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "reg", ")", ")", ";", "}", "}", "}", "if", "(", "current_function_profile", "||", "TARGET_NO_SCHED_PRO", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Generate", "the", "rest", "of", "a", "function", "'s", "prologue", "." ]

[ "arm", "\"interrupt Service Routines cannot be coded in Thumb mode\"", "512", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "shift_op", "(", "rtx", "op", ",", "HOST_WIDE_INT", "*", "amountp", ")", "{", "const", "char", "*", "mnem", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "*", "amountp", "=", "-", "1", ";", "break", ";", "case", "CONST_INT", ":", "*", "amountp", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "mnem", "=", "\"asl\"", ";", "break", ";", "case", "ASHIFTRT", ":", "mnem", "=", "\"asr\"", ";", "break", ";", "case", "LSHIFTRT", ":", "mnem", "=", "\"lsr\"", ";", "break", ";", "case", "ROTATE", ":", "gcc_assert", "(", "*", "amountp", "!=", "-", "1", ")", ";", "*", "amountp", "=", "32", "-", "*", "amountp", ";", "case", "ROTATERT", ":", "mnem", "=", "\"ror\"", ";", "break", ";", "case", "MULT", ":", "gcc_assert", "(", "*", "amountp", "!=", "-", "1", ")", ";", "*", "amountp", "=", "int_log2", "(", "*", "amountp", ")", ";", "return", "\"asl\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "*", "amountp", "!=", "-", "1", ")", "{", "if", "(", "code", "==", "ROTATERT", ")", "*", "amountp", "&=", "31", ";", "else", "if", "(", "*", "amountp", "!=", "(", "*", "amountp", "&", "31", ")", ")", "{", "if", "(", "code", "==", "ASHIFT", ")", "mnem", "=", "\"lsr\"", ";", "*", "amountp", "=", "32", ";", "}", "if", "(", "*", "amountp", "==", "0", ")", "return", "NULL", ";", "}", "return", "mnem", ";", "}", "</s>" ]

[ "Ensure", "valid", "constant", "shifts", "and", "return", "the", "appropriate", "shift", "mnemonic", "for", "the", "operation", "code", ".", "The", "returned", "result", "should", "not", "be", "overwritten", ".", "OP", "is", "the", "rtx", "code", "of", "the", "shift", ".", "On", "exit", ",", "*", "AMOUNTP", "will", "be", "-1", "if", "the", "shift", "is", "by", "a", "register", ",", "or", "a", "constant", "shift", "." ]

[ "arm", "1", "1", "1", "\"asl\"", "\"asr\"", "\"lsr\"", "1", "32", "\"ror\"", "1", "\"asl\"", "1", "31", "31", "\"lsr\"", "32", "0" ]

[]

[ "<s>", "static", "inline", "HOST_WIDE_INT", "htm_spr_regno", "(", "enum", "rs6000_builtins", "code", ")", "{", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFHAR", "||", "code", "==", "HTM_BUILTIN_SET_TFHAR", ")", "return", "TFHAR_REGNO", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFIAR", "||", "code", "==", "HTM_BUILTIN_SET_TFIAR", ")", "return", "TFIAR_REGNO", ";", "gcc_assert", "(", "code", "==", "HTM_BUILTIN_GET_TEXASR", "||", "code", "==", "HTM_BUILTIN_SET_TEXASR", "||", "code", "==", "HTM_BUILTIN_GET_TEXASRU", "||", "code", "==", "HTM_BUILTIN_SET_TEXASRU", ")", ";", "return", "TEXASR_REGNO", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SPR", "regno", "associated", "with", "the", "given", "builtin", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "do_load_for_compare", "(", "rtx", "reg", ",", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE", "(", "reg", ")", ")", "{", "case", "E_DImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqidi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhidi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_bswapsi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendsidi2", "(", "reg", ",", "src", ")", ")", ";", "}", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapdi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movdi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "E_SImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqisi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhisi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapsi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_DImode", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Figure", "out", "the", "correct", "instructions", "to", "generate", "to", "load", "data", "for", "block", "compare", ".", "MODE", "is", "used", "for", "the", "read", "from", "memory", ",", "and", "data", "is", "zero", "extended", "if", "REG", "is", "wider", "than", "MODE", ".", "If", "LE", "code", "is", "being", "generated", ",", "bswap", "loads", "are", "used", ".", "REG", "is", "the", "destination", "register", "to", "move", "the", "data", "into", ".", "MEM", "is", "the", "memory", "block", "being", "read", ".", "MODE", "is", "the", "mode", "of", "memory", "to", "use", "for", "the", "read", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", ";", "bool", "CRSpilled", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsCRField", "=", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ";", "if", "(", "CRSpilled", "&&", "IsCRField", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "IsCRField", ")", "{", "CRSpilled", "=", "true", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "MBB", ".", "insert", "(", "MI", ",", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "X12", ")", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "X12", ",", "getKillRegState", "(", "true", ")", ")", ".", "addImm", "(", "8", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ")", ";", "}", "else", "{", "MBB", ".", "insert", "(", "MI", ",", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "R12", ")", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "addFrameReference", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "R12", ",", "getKillRegState", "(", "true", ")", ")", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ")", ";", "}", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "PPC::CR2", "PPC::CR4", "PPC", "PPC::MFCR", "PPC::X12", "PPC::STW", "PPC::X12", "8", "PPC::X1", "PPC::MFCR", "PPC::R12", "PPC::STW", "PPC::R12", "PPC", "PPC" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_mainpool_start", "(", "void", ")", "{", "struct", "constant_pool", "*", "pool", ";", "rtx", "insn", ";", "pool", "=", "s390_alloc_pool", "(", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "1", ")", "==", "UNSPECV_MAIN_POOL", ")", "{", "gcc_assert", "(", "!", "pool", "->", "pool_insn", ")", ";", "pool", "->", "pool_insn", "=", "insn", ";", "}", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_execute_label", "(", "insn", ")", ")", "{", "s390_add_execute", "(", "pool", ",", "insn", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "{", "rtx", "pool_ref", "=", "NULL_RTX", ";", "find_constant_pool_ref", "(", "PATTERN", "(", "insn", ")", ",", "&", "pool_ref", ")", ";", "if", "(", "pool_ref", ")", "{", "rtx", "constant", "=", "get_pool_constant", "(", "pool_ref", ")", ";", "enum", "machine_mode", "mode", "=", "get_pool_mode", "(", "pool_ref", ")", ";", "s390_add_constant", "(", "pool", ",", "constant", ",", "mode", ")", ";", "}", "}", "}", "gcc_assert", "(", "pool", "->", "pool_insn", "||", "pool", "->", "size", "==", "0", ")", ";", "if", "(", "pool", "->", "size", ">=", "4096", ")", "{", "remove_insn", "(", "pool", "->", "pool_insn", ")", ";", "s390_free_pool", "(", "pool", ")", ";", "pool", "=", "NULL", ";", "}", "return", "pool", ";", "}", "</s>" ]

[ "Collect", "main", "literal", "pool", ".", "Return", "NULL", "on", "overflow", "." ]

[ "s390", "1", "0", "4096" ]

[]

[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "MIPS_MC", "::", "selectMipsCPU", "(", "TM", ".", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "IsSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "MIPS_MC::selectMipsCPU", "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "TM", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "true", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Mips", "Mips", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "void", "mips_expand_vec_cond_expr", "(", "machine_mode", "mode", ",", "machine_mode", "vimode", ",", "rtx", "*", "operands", ")", "{", "rtx", "cond", "=", "operands", "[", "3", "]", ";", "rtx", "cmp_op0", "=", "operands", "[", "4", "]", ";", "rtx", "cmp_op1", "=", "operands", "[", "5", "]", ";", "rtx", "cmp_res", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "mips_expand_msa_cmp", "(", "cmp_res", ",", "GET_CODE", "(", "cond", ")", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "operands", "[", "1", "]", "==", "CONSTM1_RTX", "(", "vimode", ")", "&&", "operands", "[", "2", "]", "==", "CONST0_RTX", "(", "vimode", ")", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "cmp_res", ")", ";", "else", "{", "rtx", "src1", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "rtx", "src2", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "rtx", "mask", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "rtx", "bsel", ";", "emit_move_insn", "(", "mask", ",", "cmp_res", ")", ";", "if", "(", "register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "{", "rtx", "xop1", "=", "operands", "[", "1", "]", ";", "if", "(", "mode", "!=", "vimode", ")", "{", "xop1", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "emit_move_insn", "(", "xop1", ",", "gen_rtx_SUBREG", "(", "vimode", ",", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "}", "emit_move_insn", "(", "src1", ",", "xop1", ")", ";", "}", "else", "{", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONSTM1_RTX", "(", "vimode", ")", ")", ";", "emit_move_insn", "(", "src1", ",", "mask", ")", ";", "}", "if", "(", "register_operand", "(", "operands", "[", "2", "]", ",", "mode", ")", ")", "{", "rtx", "xop2", "=", "operands", "[", "2", "]", ";", "if", "(", "mode", "!=", "vimode", ")", "{", "xop2", "=", "gen_reg_rtx", "(", "vimode", ")", ";", "emit_move_insn", "(", "xop2", ",", "gen_rtx_SUBREG", "(", "vimode", ",", "operands", "[", "2", "]", ",", "0", ")", ")", ";", "}", "emit_move_insn", "(", "src2", ",", "xop2", ")", ";", "}", "else", "{", "gcc_assert", "(", "operands", "[", "2", "]", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "emit_move_insn", "(", "src2", ",", "mask", ")", ";", "}", "bsel", "=", "gen_rtx_IOR", "(", "vimode", ",", "gen_rtx_AND", "(", "vimode", ",", "gen_rtx_NOT", "(", "vimode", ",", "mask", ")", ",", "src2", ")", ",", "gen_rtx_AND", "(", "vimode", ",", "mask", ",", "src1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "bsel", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_rtx_SUBREG", "(", "mode", ",", "mask", ",", "0", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "VEC_COND_EXPR", ",", "where", ":", "MODE", "is", "mode", "of", "the", "result", "VIMODE", "equivalent", "integer", "mode", "OPERANDS", "operands", "of", "VEC_COND_EXPR", "." ]

[ "mips", "3", "4", "5", "1", "2", "0", "1", "1", "1", "0", "1", "2", "2", "2", "0", "2", "0", "0" ]

[]

[ "<s>", "void", "SICFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SICFunctionInfo", "*", "SICFI", "=", "MF", ".", "getInfo", "<", "SICFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasCalls", "(", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "SIC", "::", "L", ")", ";", "return", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "SIC", "SIC", "SIC", "SIC", "SIC", "SIC::L" ]

[]

[ "<s>", "const", "char", "*", "msp430_select_hwmult_lib", "(", "int", "argc", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "*", "argv", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "switch", "(", "argc", ")", "{", "case", "1", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"default\"", ")", ")", "error", "(", "\"unexpected argument to %<msp430_select_hwmult_lib%>: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "default", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"hwmult\"", ")", "==", "0", ")", "{", "static", "struct", "hwmult_options", "{", "const", "char", "*", "name", ";", "const", "char", "*", "lib", ";", "}", "hwmult_options", "[", "]", "=", "{", "{", "\"none\"", ",", "\"-lmul_none\"", "}", ",", "{", "\"auto\"", ",", "\"-lmul_AUTO\"", "}", ",", "{", "\"16bit\"", ",", "\"-lmul_16\"", "}", ",", "{", "\"32bit\"", ",", "\"-lmul_32\"", "}", ",", "{", "\"f5series\"", ",", "\"-lmul_f5\"", "}", "}", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "hwmult_options", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "1", "]", ",", "hwmult_options", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "hwmult_options", "[", "i", "]", ".", "lib", ";", "}", "else", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"mcu\"", ")", "==", "0", ")", "{", "msp430_extract_mcu_data", "(", "argv", "[", "argc", "-", "1", "]", ")", ";", "if", "(", "extracted_mcu_data", ".", "name", "!=", "NULL", ")", "{", "switch", "(", "extracted_mcu_data", ".", "hwmpy", ")", "{", "case", "0", ":", "return", "\"-lmul_none\"", ";", "case", "2", ":", "case", "1", ":", "return", "\"-lmul_16\"", ";", "case", "4", ":", "return", "\"-lmul_32\"", ";", "case", "8", ":", "return", "\"-lmul_f5\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "}", "else", "error", "(", "\"unexpected first argument to %<msp430_select_hwmult_lib%>: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "case", "0", ":", "error", "(", "\"%<msp430_select_hwmult_lib%> needs one or more arguments\"", ")", ";", "break", ";", "}", "return", "\"-lmul_none\"", ";", "}", "</s>" ]

[ "Implement", "spec", "function", "`", "msp430_hwmult_lib麓", "." ]

[ "msp430", "1", "0", "\"default\"", "\"unexpected argument to %<msp430_select_hwmult_lib%>: %s\"", "0", "0", "\"hwmult\"", "0", "\"none\"", "\"-lmul_none\"", "\"auto\"", "\"-lmul_AUTO\"", "\"16bit\"", "\"-lmul_16\"", "\"32bit\"", "\"-lmul_32\"", "\"f5series\"", "\"-lmul_f5\"", "1", "0", "0", "\"mcu\"", "0", "1", "0", "\"-lmul_none\"", "2", "1", "\"-lmul_16\"", "4", "\"-lmul_32\"", "8", "\"-lmul_f5\"", "\"unexpected first argument to %<msp430_select_hwmult_lib%>: %s\"", "0", "0", "\"%<msp430_select_hwmult_lib%> needs one or more arguments\"", "\"-lmul_none\"" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "getTargetStreamer", "(", ")", ".", "emitCCBottomFunction", "(", "CurrentFnSym", "->", "getName", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "AArch64DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "AArch64", "AArch64", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "tree", "xtensa_build_va_list", "(", "void", ")", "{", "tree", "f_stk", ",", "f_reg", ",", "f_ndx", ",", "record", ";", "record", "=", "make_node", "(", "RECORD_TYPE", ")", ";", "f_stk", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_stk\"", ")", ",", "ptr_type_node", ")", ";", "f_reg", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_reg\"", ")", ",", "ptr_type_node", ")", ";", "f_ndx", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_ndx\"", ")", ",", "integer_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_stk", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_reg", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ndx", ")", "=", "record", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_stk", ";", "TREE_CHAIN", "(", "f_stk", ")", "=", "f_reg", ";", "TREE_CHAIN", "(", "f_reg", ")", "=", "f_ndx", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", ".", "This", "structure", "is", "set", "up", "by", "__builtin_saveregs", ".", "The", "__va_reg", "field", "points", "to", "a", "stack-allocated", "region", "holding", "the", "contents", "of", "the", "incoming", "argument", "registers", ".", "The", "__va_ndx", "field", "is", "an", "index", "initialized", "to", "the", "position", "of", "the", "first", "unnamed", "(", "variable", ")", "argument", ".", "This", "same", "index", "is", "also", "used", "to", "address", "the", "arguments", "passed", "in", "memory", ".", "Thus", ",", "the", "__va_stk", "field", "is", "initialized", "to", "point", "to", "the", "position", "of", "the", "first", "argument", "in", "memory", "offset", "to", "account", "for", "the", "arguments", "passed", "in", "registers", ".", "E.G.", ",", "if", "there", "are", "6", "argument", "registers", ",", "and", "each", "register", "is", "4", "bytes", ",", "then", "__va_stk", "is", "set", "to", "$", "sp", "-", "(", "6", "*", "4", ")", ";", "then", "__va_reg", "[", "N", "*", "4", "]", "references", "argument", "word", "N", "for", "0", "<", "=", "N", "<", "6", ",", "and", "__va_stk", "[", "N", "*", "4", "]", "references", "argument", "word", "N", "for", "N", ">", "=", "6", "." ]

[ "xtensa", "\"__va_stk\"", "\"__va_reg\"", "\"__va_ndx\"" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LiveRegs", ".", "init", "(", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "int", "gr5_hazard_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ",", "dest", ",", "memexpr", ";", "unsigned", "int", "out_reg", ",", "in_reg", ";", "if", "(", "GET_CODE", "(", "out_insn", ")", "==", "CALL_INSN", ")", "return", "0", ";", "out_set", "=", "single_set_and_flags", "(", "out_insn", ")", ";", "dest", "=", "SET_DEST", "(", "out_set", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", ")", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "SUBREG", ")", "dest", "=", "SUBREG_REG", "(", "dest", ")", ";", "out_reg", "=", "REGNO", "(", "dest", ")", ";", "in_set", "=", "single_set_and_flags", "(", "in_insn", ")", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "in_set", ")", ")", "==", "MEM", ")", "memexpr", "=", "XEXP", "(", "SET_SRC", "(", "in_set", ")", ",", "0", ")", ";", "else", "memexpr", "=", "XEXP", "(", "SET_DEST", "(", "in_set", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "memexpr", ")", "==", "PLUS", ")", "{", "memexpr", "=", "XEXP", "(", "memexpr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "memexpr", ")", "==", "SUBREG", ")", "in_reg", "=", "REGNO", "(", "SUBREG_REG", "(", "memexpr", ")", ")", ";", "else", "in_reg", "=", "REGNO", "(", "memexpr", ")", ";", "if", "(", "in_reg", "==", "out_reg", ")", "return", "1", ";", "}", "else", "if", "(", "TARGET_MCM", ")", "{", "if", "(", "GET_CODE", "(", "memexpr", ")", "==", "STRICT_LOW_PART", ")", "memexpr", "=", "XEXP", "(", "memexpr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "memexpr", ")", "==", "SUBREG", ")", "memexpr", "=", "SUBREG_REG", "(", "memexpr", ")", ";", "in_reg", "=", "REGNO", "(", "memexpr", ")", ";", "if", "(", "in_reg", "==", "out_reg", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "is", "called", "with", "OUT_INSN", "an", "instruction", "setting", "a", "(", "base", ")", "register", "and", "IN_INSN", "a", "read", "or", "a", "write", ".", "Return", "1", "if", "these", "instructions", "together", "constitute", "a", "pipeline", "hazard", ".", "On", "the", "original", "architecture", ",", "a", "pipeline", "data", "hazard", "occurs", "when", "the", "Dest", "of", "one", "instruction", "becomes", "the", "SrcA", "for", "an", "immediately", "following", "READ", "or", "WRITE", "instruction", "with", "a", "non-zero", "index", "(", "indexing", "occurs", "at", "the", "decode", "stage", "and", "so", "a", "NOP", "must", "be", "inserted", "in-between", "for", "this", "to", "work", ")", ".", "An", "example", "is", ":", "move.l", "r2", ",", "r1", "read.l", "r4,10", "(", "r2", ")", "On", "the", "MCM", ",", "the", "non-zero", "index", "condition", "is", "lifted", "but", "the", "hazard", "is", "patched", "up", "by", "the", "hardware", "through", "the", "injection", "of", "wait", "states", ":", "move.l", "r2", ",", "r1", "read.l", "r4", ",", "(", "r2", ")", "We", "nevertheless", "try", "to", "schedule", "instructions", "around", "this", "." ]

[ "visium", "0", "0", "0", "0", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "case", "AArch64", "::", "JumpTableDest32", ":", "case", "AArch64", "::", "JumpTableDest16", ":", "case", "AArch64", "::", "JumpTableDest8", ":", "NumBytes", "=", "12", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "0", "4", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "AArch64::TLSDESC_CALLSEQ", "16", "AArch64::JumpTableDest32", "AArch64::JumpTableDest16", "AArch64::JumpTableDest8", "12", "AArch64::SPACE", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "return", "(", "RealignStack", "&&", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createTPCMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "machine_mode", "ix86_cc_modes_compatible", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "m1", "==", "m2", ")", "return", "m1", ";", "if", "(", "GET_MODE_CLASS", "(", "m1", ")", "!=", "MODE_CC", "||", "GET_MODE_CLASS", "(", "m2", ")", "!=", "MODE_CC", ")", "return", "VOIDmode", ";", "if", "(", "(", "m1", "==", "CCGCmode", "&&", "m2", "==", "CCGOCmode", ")", "||", "(", "m1", "==", "CCGOCmode", "&&", "m2", "==", "CCGCmode", ")", ")", "return", "CCGCmode", ";", "if", "(", "(", "m1", "==", "CCNOmode", "&&", "m2", "==", "CCGOCmode", ")", "||", "(", "m1", "==", "CCGOCmode", "&&", "m2", "==", "CCNOmode", ")", ")", "return", "CCNOmode", ";", "if", "(", "m1", "==", "CCZmode", "&&", "(", "m2", "==", "CCGCmode", "||", "m2", "==", "CCGOCmode", "||", "m2", "==", "CCNOmode", ")", ")", "return", "m2", ";", "else", "if", "(", "m2", "==", "CCZmode", "&&", "(", "m1", "==", "CCGCmode", "||", "m1", "==", "CCGOCmode", "||", "m1", "==", "CCNOmode", ")", ")", "return", "m1", ";", "switch", "(", "m1", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "E_CCmode", ":", "case", "E_CCGCmode", ":", "case", "E_CCGOCmode", ":", "case", "E_CCNOmode", ":", "case", "E_CCAmode", ":", "case", "E_CCCmode", ":", "case", "E_CCOmode", ":", "case", "E_CCPmode", ":", "case", "E_CCSmode", ":", "case", "E_CCZmode", ":", "switch", "(", "m2", ")", "{", "default", ":", "return", "VOIDmode", ";", "case", "E_CCmode", ":", "case", "E_CCGCmode", ":", "case", "E_CCGOCmode", ":", "case", "E_CCNOmode", ":", "case", "E_CCAmode", ":", "case", "E_CCCmode", ":", "case", "E_CCOmode", ":", "case", "E_CCPmode", ":", "case", "E_CCSmode", ":", "case", "E_CCZmode", ":", "return", "CCmode", ";", "}", "case", "E_CCFPmode", ":", "return", "VOIDmode", ";", "}", "}", "</s>" ]

[ "If", "two", "condition", "code", "modes", "are", "compatible", ",", "return", "a", "condition", "code", "mode", "which", "is", "compatible", "with", "both", ".", "Otherwise", ",", "return", "VOIDmode", "." ]

[ "i386" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "new", "X86ExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createShadowCallStackPass", "(", ")", ")", ";", "addPass", "(", "createX86IndirectBranchTrackingPass", "(", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "XCoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "XCore", "::", "R10", ":", "XCore", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "XCore", "XCore", "XCore::R10", "XCore::SP" ]

[]

[ "<s>", "void", "AMDGPUSymbolizer", "::", "tryAddingPcLoadReferenceComment", "(", "raw_ostream", "&", "cStream", ",", "int64_t", "Value", ",", "uint64_t", "Address", ")", "{", "llvm_unreachable", "(", "\"unimplemented\"", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "comment", "on", "the", "PC-relative", "load", "." ]

[ "AMDGPU", "AMDGPU", "\"unimplemented\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "LowerCall_SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "BP", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "S7_64", ":", "Mips", "::", "S7", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "FP", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "BP", ")", ";", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "MipsFI", "->", "createEhDataRegsFI", "(", ")", ";", "if", "(", "MipsFI", "->", "isISR", "(", ")", ")", "MipsFI", "->", "createISRRegFI", "(", ")", ";", "if", "(", "ExpandPseudo", "(", "MF", ")", ".", "expand", "(", ")", ")", "{", "const", "TargetRegisterClass", "&", "RC", "=", "STI", ".", "hasMips64", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "uint64_t", "MaxSPOffset", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getIncomingArgSize", "(", ")", "+", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "MaxSPOffset", ")", ")", "return", ";", "const", "TargetRegisterClass", "&", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::S7_64", "Mips::S7", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "Mips", "16", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "static", "rtx", "riscv_force_address", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "!", "riscv_legitimate_address_p", "(", "mode", ",", "x", ",", "false", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "If", "X", "is", "not", "a", "valid", "address", "for", "mode", "MODE", ",", "force", "it", "into", "a", "register", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "BlackfinFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "adjustsStack", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Blackfin" ]

[]

[ "<s>", "void", "tilegx_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__tile__\"", ")", ";", "builtin_define", "(", "\"__tilegx__\"", ")", ";", "builtin_define", "(", "\"__tile_chip__=10\"", ")", ";", "builtin_define", "(", "\"__tile_chip_rev__=0\"", ")", ";", "builtin_assert", "(", "\"cpu=tilegx\"", ")", ";", "builtin_assert", "(", "\"machine=tilegx\"", ")", ";", "if", "(", "TARGET_32BIT", ")", "builtin_define", "(", "\"__tilegx32__\"", ")", ";", "builtin_define", "(", "\"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1\"", ")", ";", "builtin_define", "(", "\"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2\"", ")", ";", "TILEGX_CPU_CPP_ENDIAN_BUILTINS", "(", ")", ";", "GNU_USER_TARGET_OS_CPP_BUILTINS", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CPU_CPP_BUILTINS", "." ]

[ "tilegx", "\"__tile__\"", "\"__tilegx__\"", "\"__tile_chip__=10\"", "\"__tile_chip_rev__=0\"", "\"cpu=tilegx\"", "\"machine=tilegx\"", "\"__tilegx32__\"", "\"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1\"", "\"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2\"" ]

[]

[ "<s>", "static", "bool", "symbian_class_needs_attribute_p", "(", "tree", "ctype", ",", "const", "char", "*", "attribute_name", ")", "{", "VEC", "(", "tree", ",", "gc", ")", "*", "method_vec", ";", "method_vec", "=", "CLASSTYPE_METHOD_VEC", "(", "ctype", ")", ";", "if", "(", "TYPE_POLYMORPHIC_P", "(", "ctype", ")", "&&", "method_vec", "&&", "lookup_attribute", "(", "attribute_name", ",", "DECL_ATTRIBUTES", "(", "VEC_index", "(", "tree", ",", "method_vec", ",", "0", ")", ")", ")", ")", "return", "true", ";", "if", "(", "TREE_CODE", "(", "ctype", ")", "==", "RECORD_TYPE", ")", "{", "unsigned", "int", "len", ";", "len", "=", "method_vec", "?", "VEC_length", "(", "tree", ",", "method_vec", ")", ":", "0", ";", "for", "(", ";", "len", "--", ";", ")", "{", "tree", "member", "=", "VEC_index", "(", "tree", ",", "method_vec", ",", "len", ")", ";", "if", "(", "!", "member", ")", "continue", ";", "for", "(", "member", "=", "OVL_CURRENT", "(", "member", ")", ";", "member", ";", "member", "=", "OVL_NEXT", "(", "member", ")", ")", "{", "if", "(", "TREE_CODE", "(", "member", ")", "!=", "FUNCTION_DECL", ")", "continue", ";", "if", "(", "DECL_PURE_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "!", "DECL_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "lookup_attribute", "(", "attribute_name", ",", "DECL_ATTRIBUTES", "(", "member", ")", ")", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" inherits %s because\"", ",", "attribute_name", ")", ";", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "member", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" has it.\\n\"", ")", ";", "return", "true", ";", "}", "}", "}", "}", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does not inherit %s\\n\"", ",", "attribute_name", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Decide", "if", "a", "class", "needs", "to", "have", "an", "attribute", "because", "one", "of", "its", "member", "functions", "has", "the", "attribute", "." ]

[ "sh", "0", "0", "\"\"", "0", "\" inherits %s because\"", "\"\"", "0", "\" has it.\\n\"", "\"\"", "0", "\" does not inherit %s\\n\"" ]

[]

[ "<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ",", "int", "opno", ",", "bool", "speed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_FIXED", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "mode", ",", "outer", ",", "opno", ",", "&", "total", ",", "speed", ")", ";", "return", "total", ";", "}", "</s>" ]

[ "Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "." ]

[ "avr", "0", "0" ]

[]

[ "<s>", "Register", "SIRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ":", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

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

[]

[ "<s>", "void", "ARMTargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "ARMBaseRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "GPRRegClass", ";", "else", "if", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "DPRRegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "Register", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegClass", "ARM::GPRRegClass", "ARM::DPRRegClass", "ARM::DPRRegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOperandsVOP2", "(", "MachineRegisterInfo", "&", "MRI", ",", "MachineInstr", "*", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "InstrDesc", "=", "get", "(", "Opc", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "bool", "HasImplicitSGPR", "=", "findImplicitSGPRRead", "(", "*", "MI", ")", "!=", "AMDGPU", "::", "NoRegister", ";", "if", "(", "HasImplicitSGPR", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", ".", "isReg", "(", ")", "&&", "RI", ".", "isSGPRReg", "(", "MRI", ",", "Src0", ".", "getReg", "(", ")", ")", ")", "legalizeOpWithMove", "(", "MI", ",", "Src0Idx", ")", ";", "}", "if", "(", "isLegalRegOperand", "(", "MRI", ",", "InstrDesc", ".", "OpInfo", "[", "Src1Idx", "]", ",", "Src1", ")", ")", "return", ";", "if", "(", "HasImplicitSGPR", "||", "!", "MI", "->", "isCommutable", "(", ")", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "(", "!", "Src1", ".", "isImm", "(", ")", "&&", "!", "Src1", ".", "isReg", "(", ")", ")", "||", "!", "isLegalRegOperand", "(", "MRI", ",", "InstrDesc", ".", "OpInfo", "[", "Src1Idx", "]", ",", "Src0", ")", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "int", "CommutedOpc", "=", "commuteOpcode", "(", "*", "MI", ")", ";", "if", "(", "CommutedOpc", "==", "-", "1", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "MI", "->", "setDesc", "(", "get", "(", "CommutedOpc", ")", ")", ";", "unsigned", "Src0Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "Src0SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "bool", "Src0Kill", "=", "Src0", ".", "isKill", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "Src1", ".", "isReg", "(", ")", ")", "{", "Src0", ".", "ChangeToRegister", "(", "Src1", ".", "getReg", "(", ")", ",", "false", ",", "false", ",", "Src1", ".", "isKill", "(", ")", ")", ";", "Src0", ".", "setSubReg", "(", "Src1", ".", "getSubReg", "(", ")", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Should only have register or immediate operands\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Src0Reg", ",", "false", ",", "false", ",", "Src0Kill", ")", ";", "Src1", ".", "setSubReg", "(", "Src0SubReg", ")", ";", "}", "</s>" ]

[ "Legalize", "operands", "in", "MI", "by", "either", "commuting", "it", "or", "inserting", "a", "copy", "of", "src1", "." ]

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::NoRegister", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "\"Should only have register or immediate operands\"" ]

[]

[ "<s>", "const_iterator", "end", "(", ")", "const", "{", "return", "Seq", ".", "end", "(", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "MipsSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "hasMips64", "(", ")", "?", "&", "Mips", "::", "CPU64RegsRegClass", ":", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Aggressive", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips", "Mips::CPU64RegsRegClass", "Mips::CPURegsRegClass" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCyles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "R600" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "Attribute", "SFAttr", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ";", "bool", "SoftFloat", "=", "!", "SFAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "SFAttr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ":", "Options", ".", "UseSoftFloat", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "+", "(", "SoftFloat", "?", "\"use-soft-float=true\"", ":", "\"use-soft-float=false\"", ")", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"use-soft-float=true\"", "\"use-soft-float=false\"", "X86" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "NumBytes", "+=", "92", ";", "NumBytes", "=", "(", "NumBytes", "+", "7", ")", "&", "~", "7", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "-", "4096", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVEri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "NumBytes", ">>", "10U", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ORri", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addImm", "(", "NumBytes", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVErr", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "92", "7", "7", "4096", "SP::SAVEri", "SP::O6", "SP::O6", "10U", "SP::SETHIi", "SP::G1", "SP::ORri", "SP::G1", "SP::G1", "1", "10", "1", "SP::SAVErr", "SP::O6", "SP::O6", "SP::G1" ]

[]

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

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

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

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "DLX" ]

[]

[ "<s>", "const", "char", "*", "OR1KTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "OR1KISD", "::", "ADJDYNALLOC", ":", "return", "\"OR1KISD::ADJDYNALLOC\"", ";", "case", "OR1KISD", "::", "RET_FLAG", ":", "return", "\"OR1KISD::RET_FLAG\"", ";", "case", "OR1KISD", "::", "CALL", ":", "return", "\"OR1KISD::CALL\"", ";", "case", "OR1KISD", "::", "SELECT_CC", ":", "return", "\"OR1KISD::SELECT_CC\"", ";", "case", "OR1KISD", "::", "SET_FLAG", ":", "return", "\"OR1KISD::SET_FLAG\"", ";", "case", "OR1KISD", "::", "BR_CC", ":", "return", "\"OR1KISD::BR_CC\"", ";", "case", "OR1KISD", "::", "Wrapper", ":", "return", "\"OR1KISD::Wrapper\"", ";", "case", "OR1KISD", "::", "FF1", ":", "return", "\"OR1KISD::FF1\"", ";", "case", "OR1KISD", "::", "FL1", ":", "return", "\"OR1KISD::FL1\"", ";", "case", "OR1KISD", "::", "HI", ":", "return", "\"OR1KISD::HI\"", ";", "case", "OR1KISD", "::", "LO", ":", "return", "\"OR1KISD::LO\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "OR1K", "OR1K", "OR1KISD::ADJDYNALLOC", "\"OR1KISD::ADJDYNALLOC\"", "OR1KISD::RET_FLAG", "\"OR1KISD::RET_FLAG\"", "OR1KISD::CALL", "\"OR1KISD::CALL\"", "OR1KISD::SELECT_CC", "\"OR1KISD::SELECT_CC\"", "OR1KISD::SET_FLAG", "\"OR1KISD::SET_FLAG\"", "OR1KISD::BR_CC", "\"OR1KISD::BR_CC\"", "OR1KISD::Wrapper", "\"OR1KISD::Wrapper\"", "OR1KISD::FF1", "\"OR1KISD::FF1\"", "OR1KISD::FL1", "\"OR1KISD::FL1\"", "OR1KISD::HI", "\"OR1KISD::HI\"", "OR1KISD::LO", "\"OR1KISD::LO\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsV3EHReturn", "[", "]", "=", "{", "Hexagon", "::", "R0", ",", "Hexagon", "::", "R1", ",", "Hexagon", "::", "R2", ",", "Hexagon", "::", "R3", ",", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "bool", "HasEHReturn", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "switch", "(", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "HexagonSubtarget", "::", "V4", ":", "case", "HexagonSubtarget", "::", "V5", ":", "case", "HexagonSubtarget", "::", "V55", ":", "case", "HexagonSubtarget", "::", "V60", ":", "return", "HasEHReturn", "?", "CalleeSavedRegsV3EHReturn", ":", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R0", "Hexagon::R1", "Hexagon::R2", "Hexagon::R3", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

[ "<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", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerAccessVectorElement", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerIntrinsic", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "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", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::SIGN_EXTEND_INREG", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SHL", "ISD::SRA", "ISD::SRL" ]

[]

[ "<s>", "unsigned", "int", "mt_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ";", "unsigned", "int", "var_size", ";", "unsigned", "int", "args_size", ";", "unsigned", "int", "pretend_size", ";", "unsigned", "int", "extra_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "frame_size", ";", "unsigned", "int", "reg_mask", ";", "var_size", "=", "size", ";", "args_size", "=", "current_function_outgoing_args_size", ";", "pretend_size", "=", "current_function_pretend_args_size", ";", "extra_size", "=", "FIRST_PARM_OFFSET", "(", "0", ")", ";", "total_size", "=", "extra_size", "+", "pretend_size", "+", "args_size", "+", "var_size", ";", "reg_size", "=", "0", ";", "reg_mask", "=", "0", ";", "for", "(", "regno", "=", "GPR_R0", ";", "regno", "<=", "GPR_LAST", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "reg_mask", "|=", "1", "<<", "regno", ";", "}", "}", "current_frame_info", ".", "save_fp", "=", "(", "regs_ever_live", "[", "GPR_FP", "]", "||", "frame_pointer_needed", "||", "interrupt_handler", ")", ";", "current_frame_info", ".", "save_lr", "=", "(", "regs_ever_live", "[", "GPR_LINK", "]", "||", "profile_flag", "||", "interrupt_handler", ")", ";", "reg_size", "+=", "(", "current_frame_info", ".", "save_fp", "+", "current_frame_info", ".", "save_lr", ")", "*", "UNITS_PER_WORD", ";", "total_size", "+=", "reg_size", ";", "total_size", "=", "(", "(", "total_size", "+", "3", ")", "&", "~", "3", ")", ";", "frame_size", "=", "total_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "frame_size", "=", "args_size", "+", "var_size", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "extra_size", "=", "extra_size", ";", "current_frame_info", ".", "reg_mask", "=", "reg_mask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "offset", "between", "the", "frame", "pointer", "and", "the", "stack", "pointer", "for", "the", "current", "function", ".", "SIZE", "is", "the", "number", "of", "bytes", "of", "space", "needed", "for", "local", "variables", "." ]

[ "mt", "0", "0", "0", "1", "3", "3" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "insn", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "arc", "100", "1" ]

[]

[ "<s>", "static", "void", "prepare_pic_move", "(", "rtx", "*", "operands", ",", "machine_mode", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", "&&", "flag_pic", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "{", "rtx", "temp", "=", "(", "reload_in_progress", "?", "operands", "[", "0", "]", ":", "flag_pic", "?", "gen_reg_rtx", "(", "Pmode", ")", ":", "NULL_RTX", ")", ";", "operands", "[", "1", "]", "=", "arc_legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "arc", "0", "1", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "WebAssemblyAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "AsmVariant", "!=", "0", ")", "report_fatal_error", "(", "\"There are no defined alternate asm variants\"", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "OS", "<<", "regToString", "(", "MO", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "WebAssembly", "WebAssembly", "0", "\"There are no defined alternate asm variants\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "fr30_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "address", ")", "{", "switch", "(", "GET_CODE", "(", "address", ")", ")", "{", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "stream", ",", "address", ")", ";", "break", ";", "default", ":", "fprintf", "(", "stderr", ",", "\"code = %x\\n\"", ",", "GET_CODE", "(", "address", ")", ")", ";", "debug_rtx", "(", "address", ")", ";", "output_operand_lossage", "(", "\"fr30_print_operand_address: unhandled address\"", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "fr30", "\"code = %x\\n\"", "\"fr30_print_operand_address: unhandled address\"" ]

[]

[ "<s>", "bool", "Mips16HardFloat", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Run on Module Mips16HardFloat\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "Module", "::", "iterator", "F", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "F", "!=", "E", ";", "++", "F", ")", "{", "if", "(", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", "&&", "F", "->", "hasFnAttribute", "(", "\"use-soft-float\"", ")", ")", "{", "removeUseSoftFloat", "(", "*", "F", ")", ";", "continue", ";", "}", "if", "(", "F", "->", "isDeclaration", "(", ")", "||", "F", "->", "hasFnAttribute", "(", "\"mips16_fp_stub\"", ")", "||", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", ")", "continue", ";", "Modified", "|=", "fixupFPReturnAndCall", "(", "*", "F", ",", "&", "M", ",", "TM", ")", ";", "FPParamVariant", "V", "=", "whichFPParamVariantNeeded", "(", "*", "F", ")", ";", "if", "(", "V", "!=", "NoSig", ")", "{", "Modified", "=", "true", ";", "createFPFnStub", "(", "&", "*", "F", ",", "&", "M", ",", "V", ",", "TM", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "Mips", "Mips", "\"Run on Module Mips16HardFloat\\n\"", "\"nomips16\"", "\"use-soft-float\"", "\"mips16_fp_stub\"", "\"nomips16\"" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "padShortFunctions", "(", ")", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "LEAusesAG", "(", ")", ")", "{", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createX86NaClRewritePass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "this", "->", "F", "=", "&", "F", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "po_begin", "(", "*", "I", ")", ",", "LE", "=", "po_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "Changed", "|=", "runOnLoop", "(", "*", "L", ")", ";", "VisitedBlocks", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "HSAILDAGToDAGISel", "::", "IsProfitableToFold", "(", "SDValue", "N", ",", "SDNode", "*", "U", ",", "SDNode", "*", "Root", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "IsProfitableToFold", "-", "Returns", "true", "if", "it", "'s", "profitable", "to", "fold", "the", "specific", "operand", "node", "N", "of", "U", "during", "instruction", "selection", "that", "starts", "at", "Root", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "JITInfo", "(", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

[ "Create", "an", "ARM", "architecture", "model", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "AArch64", "::", "XSP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"sp\"", "AArch64::XSP", "0", "\"Invalid register name global variable\"" ]

[]

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

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

[ "TVM", "TVM", "TVM" ]

[]

[ "<s>", "unsigned", "J2MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "J2", "::", "Fixups", "FixupKind", "=", "J2", "::", "fixup_J2_NONE", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "J2", "::", "BSR", ":", "case", "J2", "::", "BRA", ":", "FixupKind", "=", "J2", "::", "fixup_J2_PC2_12", ";", "break", ";", "case", "J2", "::", "BT", ":", "FixupKind", "=", "J2", "::", "fixup_J2_PC2_8", ";", "break", ";", "case", "J2", "::", "MOV32PCR", ":", "FixupKind", "=", "J2", "::", "fixup_J2_PC4_8", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Opcode not handled.\"", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "J2", "J2", "J2::Fixups", "J2::fixup_J2_NONE", "J2::BSR", "J2::BRA", "J2::fixup_J2_PC2_12", "J2::BT", "J2::fixup_J2_PC2_8", "J2::MOV32PCR", "J2::fixup_J2_PC4_8", "\"Opcode not handled.\"", "0", "0" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "opt_machine_mode", "vmode", "=", "mode_for_vector", "(", "mode", ",", "16", "/", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "vmode", ".", "exists", "(", ")", "&&", "!", "VECTOR_MEM_NONE_P", "(", "vmode", ".", "require", "(", ")", ")", ")", "return", "vmode", ".", "require", "(", ")", ";", "return", "word_mode", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.preferred_simd_mode", "." ]

[ "rs6000", "16" ]

[]

[ "<s>", "bool", "sh_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "SPECIAL_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPUL_REG", ")", "return", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ";", "if", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "mode", "==", "SFmode", ")", "return", "true", ";", "if", "(", "mode", "==", "V2SFmode", ")", "{", "if", "(", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "2", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V4SFmode", ")", "{", "if", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "4", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V16SFmode", ")", "return", "regno", "==", "FIRST_XD_REG", ";", "if", "(", "FP_REGISTER_P", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", "||", "(", "(", "TARGET_SH2E", ")", "&&", "mode", "==", "SCmode", ")", "||", "(", "(", "(", "TARGET_FPU_DOUBLE", "&&", "mode", "==", "DFmode", ")", "||", "mode", "==", "DCmode", ")", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "1", ")", "==", "0", ")", "||", "(", "TARGET_SH4", "&&", "mode", "==", "TImode", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "3", ")", "==", "0", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "XD_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "DFmode", ";", "if", "(", "regno", "==", "PR_REG", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPSCR_REG", ")", "return", "mode", "==", "SImode", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "We", "can", "allow", "any", "mode", "in", "any", "general", "register", ".", "The", "special", "registers", "only", "allow", "SImode", ".", "Do", "n't", "allow", "any", "mode", "in", "the", "PR", ".", "We", "can", "not", "hold", "DCmode", "values", "in", "the", "XD", "registers", "because", "alter_reg", "handles", "subregs", "of", "them", "incorrectly", ".", "We", "could", "work", "around", "this", "by", "spacing", "the", "XD", "registers", "like", "the", "DR", "registers", ",", "but", "this", "would", "require", "additional", "memory", "in", "every", "compilation", "to", "hold", "larger", "register", "vectors", ".", "We", "could", "hold", "SFmode", "/", "SCmode", "values", "in", "XD", "registers", ",", "but", "that", "would", "require", "a", "tertiary", "reload", "when", "reloading", "from", "/", "to", "memory", ",", "and", "a", "secondary", "reload", "to", "reload", "from", "/", "to", "general", "regs", ";", "that", "seems", "to", "be", "a", "losing", "proposition", ".", "We", "want", "to", "allow", "TImode", "FP", "regs", "so", "that", "when", "V4SFmode", "is", "loaded", "as", "TImode", ",", "it", "wo", "n't", "be", "ferried", "through", "GP", "registers", "first", "." ]

[ "sh", "2", "0", "4", "0", "1", "0", "3", "0" ]

[]

[ "<s>", "static", "SDValue", "getSplatValue", "(", "SDNode", "*", "N", ")", "{", "if", "(", "auto", "*", "BuildVec", "=", "dyn_cast", "<", "BuildVectorSDNode", ">", "(", "N", ")", ")", "{", "return", "BuildVec", "->", "getSplatValue", "(", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "If", "V", "is", "a", "splat", "vector", ",", "return", "its", "scalar", "source", "operand", "by", "extracting", "that", "element", "from", "the", "source", "vector", "." ]

[ "VE" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_RegMask", ";", "return", "CSR_SystemZ_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "emit_soft_tfmode_libcall", "(", "const", "char", "*", "func_name", ",", "int", "nargs", ",", "rtx", "*", "operands", ")", "{", "rtx", "ret_slot", "=", "NULL", ",", "arg", "[", "3", "]", ",", "func_sym", ";", "int", "i", ";", "gcc_assert", "(", "nargs", "==", "2", "||", "nargs", "==", "3", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nargs", ";", "++", "i", ")", "{", "rtx", "this_arg", "=", "operands", "[", "i", "]", ";", "rtx", "this_slot", ";", "if", "(", "GET_MODE", "(", "this_arg", ")", "==", "TFmode", ")", "{", "int", "force_stack_temp", ";", "force_stack_temp", "=", "0", ";", "if", "(", "TARGET_BUGGY_QP_LIB", "&&", "i", "==", "0", ")", "force_stack_temp", "=", "1", ";", "if", "(", "GET_CODE", "(", "this_arg", ")", "==", "MEM", "&&", "!", "force_stack_temp", ")", "{", "tree", "expr", "=", "MEM_EXPR", "(", "this_arg", ")", ";", "if", "(", "expr", ")", "mark_addressable", "(", "expr", ")", ";", "this_arg", "=", "XEXP", "(", "this_arg", ",", "0", ")", ";", "}", "else", "if", "(", "CONSTANT_P", "(", "this_arg", ")", "&&", "!", "force_stack_temp", ")", "{", "this_slot", "=", "force_const_mem", "(", "TFmode", ",", "this_arg", ")", ";", "this_arg", "=", "XEXP", "(", "this_slot", ",", "0", ")", ";", "}", "else", "{", "this_slot", "=", "assign_stack_temp", "(", "TFmode", ",", "GET_MODE_SIZE", "(", "TFmode", ")", ")", ";", "if", "(", "i", ">", "0", ")", "emit_move_insn", "(", "this_slot", ",", "this_arg", ")", ";", "else", "ret_slot", "=", "this_slot", ";", "this_arg", "=", "XEXP", "(", "this_slot", ",", "0", ")", ";", "}", "}", "arg", "[", "i", "]", "=", "this_arg", ";", "}", "func_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "func_name", ")", ";", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "TFmode", ")", "{", "if", "(", "nargs", "==", "2", ")", "emit_library_call", "(", "func_sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "2", ",", "arg", "[", "0", "]", ",", "GET_MODE", "(", "arg", "[", "0", "]", ")", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ")", ";", "else", "emit_library_call", "(", "func_sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "arg", "[", "0", "]", ",", "GET_MODE", "(", "arg", "[", "0", "]", ")", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ",", "arg", "[", "2", "]", ",", "GET_MODE", "(", "arg", "[", "2", "]", ")", ")", ";", "if", "(", "ret_slot", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ret_slot", ")", ";", "}", "else", "{", "rtx", "ret", ";", "gcc_assert", "(", "nargs", "==", "2", ")", ";", "ret", "=", "emit_library_call_value", "(", "func_sym", ",", "operands", "[", "0", "]", ",", "LCT_NORMAL", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "1", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ")", ";", "if", "(", "ret", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ret", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "call", "to", "FUNC", "with", "OPERANDS", ".", "Operand", "0", "is", "the", "return", "value", ".", "Unlike", "normal", "calls", ",", "TFmode", "operands", "are", "passed", "by", "reference", ".", "It", "is", "assumed", "that", "no", "more", "than", "3", "operands", "are", "required", "." ]

[ "sparc", "3", "2", "3", "0", "0", "0", "1", "0", "0", "0", "0", "0", "2", "2", "0", "0", "1", "1", "3", "0", "0", "1", "1", "2", "2", "0", "2", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "WebAssemblyPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Peephole **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "CALL", ":", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op1", ".", "isSymbol", "(", ")", ")", "{", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "if", "(", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ")", "{", "LibFunc", "Func", ";", "if", "(", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "{", "const", "auto", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isReg", "(", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Register", "OldReg", "=", "MO", ".", "getReg", "(", ")", ";", "Register", "NewReg", "=", "Op2", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "NewReg", ")", "!=", "MRI", ".", "getRegClass", "(", "OldReg", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"", ")", ";", "Changed", "|=", "maybeRewriteToDrop", "(", "OldReg", ",", "NewReg", ",", "MO", ",", "MFI", ",", "MRI", ")", ";", "}", "}", "}", "break", ";", "}", "case", "WebAssembly", "::", "RETURN", ":", "Changed", "|=", "maybeRewriteToFallthrough", "(", "MI", ",", "MBB", ",", "MF", ",", "MFI", ",", "MRI", ",", "TII", ")", ";", "break", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Peephole **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::CALL", "1", "2", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", "0", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"", "WebAssembly::RETURN" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isThroughputPattern", "(", "MachineCombinerPattern", "Pattern", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "default", ":", "break", ";", "case", "MachineCombinerPattern", "::", "FMULADDH_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDH_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBH_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBH_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULADDS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP2", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBH_OP1", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i16_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i16_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv8i16_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv8i16_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f16_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f16_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv8f16_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv8f16_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i16_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i16_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv8i16_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLSv8i16_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f16_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f16_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv8f16_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLSv8f16_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f32_OP2", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "code", "sequence", "can", "improve", "throughput", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", "&&", "!", "isSupportedReturnType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "ArgInfo", "ArgRetInfo", "(", "VRegs", ",", "Val", "->", "getType", "(", ")", ")", ";", "setArgFlags", "(", "ArgRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "DL", ",", "ArgRetInfo", ",", "0", ",", "RetInfos", ",", "OrigArgIndices", ")", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "RetInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "MipsOutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "RetInfos", ")", ")", "{", "return", "false", ";", "}", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "8", "8", "0", "ISD::OutputArg", "8", "16", "Mips", "Mips" ]

[]

[ "<s>", "const", "char", "*", "nvptx_output_return", "(", "void", ")", "{", "machine_mode", "mode", "=", "(", "machine_mode", ")", "cfun", "->", "machine", "->", "return_mode", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tst.param%s\\t[%s_out], %s;\\n\"", ",", "nvptx_ptx_type_from_mode", "(", "mode", ",", "false", ")", ",", "reg_names", "[", "NVPTX_RETURN_REGNUM", "]", ",", "reg_names", "[", "NVPTX_RETURN_REGNUM", "]", ")", ";", "return", "\"ret;\"", ";", "}", "</s>" ]

[ "Output", "a", "return", "instruction", ".", "Also", "copy", "the", "return", "value", "to", "its", "outgoing", "location", "." ]

[ "nvptx", "\"\\tst.param%s\\t[%s_out], %s;\\n\"", "\"ret;\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_Ghc_RegMask", ";", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "formatted_raw_ostream", "&", "Out", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ")", "{", "MCContext", "*", "Context", "=", "0", ";", "if", "(", "addCommonCodeGenPasses", "(", "PM", ",", "DisableVerify", ",", "Context", ")", ")", "return", "true", ";", "assert", "(", "Context", "!=", "0", "&&", "\"Failed to get MCContext\"", ")", ";", "if", "(", "hasMCSaveTempLabels", "(", ")", ")", "Context", "->", "setAllowTemporaryLabels", "(", "false", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "getMCAsmInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ";", "OwningPtr", "<", "MCStreamer", ">", "AsmStreamer", ";", "switch", "(", "FileType", ")", "{", "default", ":", "return", "true", ";", "case", "CGFT_AssemblyFile", ":", "{", "MCInstPrinter", "*", "InstPrinter", "=", "getTarget", "(", ")", ".", "createMCInstPrinter", "(", "MAI", ".", "getAssemblerDialect", "(", ")", ",", "MAI", ",", "STI", ")", ";", "MCCodeEmitter", "*", "MCE", "=", "0", ";", "MCAsmBackend", "*", "MAB", "=", "0", ";", "MCStreamer", "*", "S", "=", "getTarget", "(", ")", ".", "createAsmStreamer", "(", "*", "Context", ",", "Out", ",", "true", ",", "hasMCUseLoc", "(", ")", ",", "hasMCUseCFI", "(", ")", ",", "hasMCUseDwarfDirectory", "(", ")", ",", "InstPrinter", ",", "MCE", ",", "MAB", ",", "false", ")", ";", "AsmStreamer", ".", "reset", "(", "S", ")", ";", "break", ";", "}", "case", "CGFT_ObjectFile", ":", "{", "llvm_unreachable", "(", "\"Object file emission is not supported with PTX\"", ")", ";", "}", "case", "CGFT_Null", ":", "AsmStreamer", ".", "reset", "(", "createNullStreamer", "(", "*", "Context", ")", ")", ";", "break", ";", "}", "FunctionPass", "*", "Printer", "=", "getTarget", "(", ")", ".", "createAsmPrinter", "(", "*", "this", ",", "*", "AsmStreamer", ")", ";", "if", "(", "Printer", "==", "0", ")", "return", "true", ";", "AsmStreamer", ".", "take", "(", ")", ";", "PM", ".", "add", "(", "Printer", ")", ";", "PM", ".", "add", "(", "createGCInfoDeleter", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "PTX", "PTX", "0", "0", "\"Failed to get MCContext\"", "0", "0", "\"Object file emission is not supported with PTX\"", "0" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Sparc" ]

[]

[ "<s>", "rtx", "tilegx_eh_return_handler_rtx", "(", "void", ")", "{", "rtx", "tmp", "=", "gen_frame_mem", "(", "Pmode", ",", "hard_frame_pointer_rtx", ")", ";", "MEM_VOLATILE_P", "(", "tmp", ")", "=", "true", ";", "return", "tmp", ";", "}", "</s>" ]

[ "Implement", "EH_RETURN_HANDLER_RTX", ".", "The", "MEM", "needs", "to", "be", "volatile", "to", "prevent", "it", "from", "being", "deleted", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "R600MachineCFGStructurizer", "::", "prepare", "(", ")", "{", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"R600MachineCFGStructurizer::prepare\\n\"", ";", ")", ";", "orderBlocks", "(", "FuncRep", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "DEFAULT_VEC_SLOTS", ">", "RetBlks", ";", "for", "(", "MachineLoop", "*", "LoopRep", ":", "*", "MLI", ")", "{", "MBBVector", "ExitingMBBs", ";", "LoopRep", "->", "getExitingBlocks", "(", "ExitingMBBs", ")", ";", "if", "(", "ExitingMBBs", ".", "size", "(", ")", "==", "0", ")", "{", "MachineBasicBlock", "*", "DummyExitBlk", "=", "normalizeInfiniteLoopExit", "(", "LoopRep", ")", ";", "if", "(", "DummyExitBlk", ")", "RetBlks", ".", "push_back", "(", "DummyExitBlk", ")", ";", "}", "}", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "OrderedBlks", ")", "{", "removeUnconditionalBranch", "(", "MBB", ")", ";", "removeRedundantConditionalBranch", "(", "MBB", ")", ";", "if", "(", "isReturnBlock", "(", "MBB", ")", ")", "{", "RetBlks", ".", "push_back", "(", "MBB", ")", ";", "}", "assert", "(", "MBB", "->", "succ_size", "(", ")", "<=", "2", ")", ";", "}", "if", "(", "RetBlks", ".", "size", "(", ")", ">=", "2", ")", "{", "addDummyExitBlock", "(", "RetBlks", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "R600", "\"R600MachineCFGStructurizer::prepare\\n\"", "0", "2", "2" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "GR8_NOREXRegClass", ")", "return", "RC", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegClass", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "LORegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "LORegs64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "Mips", "0U", "Mips::CPU16RegsRegClass", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPURegsRegClass", "MVT::i64", "Mips", "0U", "Mips::CPU64RegsRegClass", "0u", "0", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::FGR64RegClass", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::CPURegsRegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::CPU64RegsRegClass", "MVT::i32", "Mips::LO", "Mips::LORegsRegClass", "Mips::LO64", "Mips::LORegs64RegClass", "0u", "0" ]

[]

[ "<s>", "int", "arm_no_early_mul_dep", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "rtx", "value", "=", "PATTERN", "(", "producer", ")", ";", "rtx", "op", "=", "PATTERN", "(", "consumer", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "COND_EXEC", ")", "value", "=", "COND_EXEC_CODE", "(", "value", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "PARALLEL", ")", "value", "=", "XVECEXP", "(", "value", ",", "0", ",", "0", ")", ";", "value", "=", "XEXP", "(", "value", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "COND_EXEC", ")", "op", "=", "COND_EXEC_CODE", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PARALLEL", ")", "op", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "return", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "!", "reg_overlap_mentioned_p", "(", "value", ",", "XEXP", "(", "op", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "CONSUMER", "(", "a", "mul", "or", "mac", "op", ")", "does", "not", "have", "an", "early", "register", "mult", "dependency", "on", "the", "result", "of", "PRODUCER", "." ]

[ "arm", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "lxvrse_expand_builtin", "(", "rtx", "target", ",", "insn_code", "icode", ",", "rtx", "*", "op", ",", "machine_mode", "tmode", ",", "machine_mode", "smode", ")", "{", "rtx", "pat", ",", "addr", ";", "op", "[", "1", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "1", "]", ")", ";", "if", "(", "op", "[", "0", "]", "==", "const0_rtx", ")", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "op", "[", "1", "]", ")", ";", "else", "{", "op", "[", "0", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "0", "]", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "smode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op", "[", "1", "]", ",", "op", "[", "0", "]", ")", ")", ";", "}", "rtx", "discratch", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "rtx", "tiscratch", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "tiscratch", ",", "addr", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "rtx", "temp1", ";", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrbx", ")", "{", "temp1", "=", "simplify_gen_subreg", "(", "V16QImode", ",", "tiscratch", ",", "TImode", ",", "0", ")", ";", "emit_insn", "(", "gen_vsx_sign_extend_v16qi_v2di", "(", "discratch", ",", "temp1", ")", ")", ";", "}", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrhx", ")", "{", "temp1", "=", "simplify_gen_subreg", "(", "V8HImode", ",", "tiscratch", ",", "TImode", ",", "0", ")", ";", "emit_insn", "(", "gen_vsx_sign_extend_v8hi_v2di", "(", "discratch", ",", "temp1", ")", ")", ";", "}", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrwx", ")", "{", "temp1", "=", "simplify_gen_subreg", "(", "V4SImode", ",", "tiscratch", ",", "TImode", ",", "0", ")", ";", "emit_insn", "(", "gen_vsx_sign_extend_v4si_v2di", "(", "discratch", ",", "temp1", ")", ")", ";", "}", "else", "if", "(", "icode", "==", "CODE_FOR_vsx_lxvrdx", ")", "discratch", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "tiscratch", ",", "TImode", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "rtx", "temp2", "=", "simplify_gen_subreg", "(", "TImode", ",", "discratch", ",", "V2DImode", ",", "0", ")", ";", "emit_insn", "(", "gen_extendditi2_vector", "(", "target", ",", "temp2", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "builtin", "function", "that", "loads", "a", "scalar", "into", "a", "vector", "register", "with", "sign", "extension", ",", "and", "return", "the", "expanded", "rtx", "." ]

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

[]

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

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

[ "M68k", "0" ]

[]

[ "<s>", "static", "void", "replace_ltrel_base", "(", "rtx", "*", "x", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "x", ",", "1", ")", "==", "UNSPEC_LTREL_BASE", ")", "{", "*", "x", "=", "XVECEXP", "(", "*", "x", ",", "0", ",", "1", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "*", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "*", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "replace_ltrel_base", "(", "&", "XEXP", "(", "*", "x", ",", "i", ")", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "*", "x", ",", "i", ")", ";", "j", "++", ")", "replace_ltrel_base", "(", "&", "XVECEXP", "(", "*", "x", ",", "i", ",", "j", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Replace", "any", "occurrence", "of", "UNSPEC_LTREL_BASE", "in", "X", "with", "its", "base", "." ]

[ "s390", "1", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "int", "AltOpc", "=", "PPC", "::", "getAltVSXFMAOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "AltOpc", "==", "-", "1", ")", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "SrcOpIdx1", "=", "2", ";", "SrcOpIdx2", "=", "3", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::getAltVSXFMAOpcode", "1", "2", "3" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "M88kFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "void", "rws_update", "(", "int", "regno", ",", "struct", "reg_flags", "flags", ",", "int", "pred", ")", "{", "if", "(", "pred", ")", "rws_sum", "[", "regno", "]", ".", "write_count", "++", ";", "else", "rws_sum", "[", "regno", "]", ".", "write_count", "=", "2", ";", "rws_sum", "[", "regno", "]", ".", "written_by_fp", "|=", "flags", ".", "is_fp", ";", "rws_sum", "[", "regno", "]", ".", "written_by_and", "=", "flags", ".", "is_and", ";", "rws_sum", "[", "regno", "]", ".", "written_by_or", "=", "flags", ".", "is_or", ";", "rws_sum", "[", "regno", "]", ".", "first_pred", "=", "pred", ";", "}", "</s>" ]

[ "Update", "*", "RWS", "for", "REGNO", ",", "which", "is", "being", "written", "by", "the", "current", "instruction", ",", "with", "predicate", "PRED", ",", "and", "associated", "register", "flags", "in", "FLAGS", "." ]

[ "ia64", "2" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "O", "<<", "\"0, \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'U'", ":", "case", "'X'", ":", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"0, \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "static", "int", "thumb2_legitimate_index_p", "(", "machine_mode", "mode", ",", "rtx", "index", ",", "int", "strict_p", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "index", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "256", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ")", "{", "if", "(", "!", "TARGET_LDRD", "||", "mode", "!=", "DImode", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "}", "if", "(", "TARGET_NEON", "&&", "VALID_NEON_QREG_MODE", "(", "mode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1016", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "TARGET_NEON", "&&", "VALID_NEON_DREG_MODE", "(", "mode", ")", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "1024", "&&", "INTVAL", "(", "index", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "index", ",", "strict_p", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", "return", "1", ";", "if", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "code", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "index", ")", ";", "return", "val", ">", "-", "256", "&&", "val", "<", "256", "&&", "(", "val", "&", "3", ")", "==", "0", ";", "}", "else", "return", "0", ";", "}", "if", "(", "code", "==", "MULT", ")", "{", "rtx", "xiop0", "=", "XEXP", "(", "index", ",", "0", ")", ";", "rtx", "xiop1", "=", "XEXP", "(", "index", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xiop0", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop1", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xiop1", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop0", ")", ")", ")", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "rtx", "op", "=", "XEXP", "(", "index", ",", "1", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "XEXP", "(", "index", ",", "0", ")", ",", "strict_p", ")", "&&", "CONST_INT_P", "(", "op", ")", "&&", "INTVAL", "(", "op", ")", ">", "0", "&&", "INTVAL", "(", "op", ")", "<=", "3", ")", ";", "}", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "4096", "&&", "INTVAL", "(", "index", ")", ">", "-", "256", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "INDEX", "is", "a", "valid", "Thumb-2", "address", "index", "operand", "." ]

[ "arm", "1024", "256", "3", "0", "1024", "1024", "3", "0", "1016", "1024", "3", "0", "1024", "1024", "3", "0", "4", "1", "256", "256", "3", "0", "0", "0", "1", "1", "0", "0", "3", "4096", "256" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "addr", ")", "{", "enum", "tls_model", "tls_kind", "=", "TLS_MODEL_NONE", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "addr", ")", ";", "return", "tls_kind", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "." ]

[ "ia64", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGW", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "MSP430", "::", "FPW", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::PCW", "MSP430::SPW", "MSP430::SRW", "MSP430::CGW", "MSP430::FPW" ]

[]

[ "<s>", "static", "void", "xputenv", "(", "const", "char", "*", "string", ")", "{", "if", "(", "verbose", ")", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "string", ")", ";", "putenv", "(", "CONST_CAST", "(", "char", "*", ",", "string", ")", ")", ";", "}", "</s>" ]

[ "Add", "or", "change", "the", "value", "of", "an", "environment", "variable", ",", "outputting", "the", "change", "to", "standard", "error", "if", "in", "verbose", "mode", "." ]

[ "i386", "\"%s\\n\"" ]

[]

[ "<s>", "void", "PPCOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Immediate", ":", "case", "ContextImmediate", ":", "OS", "<<", "getImm", "(", ")", ";", "break", ";", "case", "Expression", ":", "getExpr", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "TLSRegister", ":", "getTLSReg", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "PowerPC", "PPC", "\"'\"", "\"'\"" ]

[]

[ "<s>", "int", "num_insns_constant_wide", "(", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "CONST_OK_FOR_LETTER_P", "(", "value", ",", "'I'", ")", ")", "return", "1", ";", "else", "if", "(", "CONST_OK_FOR_LETTER_P", "(", "value", ",", "'L'", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_POWERPC64", ")", "{", "HOST_WIDE_INT", "low", "=", "(", "(", "value", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "HOST_WIDE_INT", "high", "=", "value", ">>", "31", ";", "if", "(", "high", "==", "0", "||", "high", "==", "-", "1", ")", "return", "2", ";", "high", ">>=", "1", ";", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_wide", "(", "high", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_wide", "(", "high", ")", "+", "num_insns_constant_wide", "(", "low", ")", "+", "1", ")", ";", "}", "else", "return", "2", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "an", "integer", "register", "." ]

[ "rs6000", "1", "1", "0xffffffff", "0x80000000", "0x80000000", "31", "0", "1", "2", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "OmitRegisterFromClobberLists", "(", "unsigned", "RegNo", ")", "{", "return", "X86MCRegisterClasses", "[", "X86", "::", "SEGMENT_REGRegClassID", "]", ".", "contains", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Allows", "targets", "to", "let", "registers", "opt", "out", "of", "clobber", "lists", "." ]

[ "X86", "X86", "X86", "X86::SEGMENT_REGRegClassID" ]

[]

[ "<s>", "void", "moxie_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "rtx", "operand", "=", "x", ";", "switch", "(", "code", ")", "{", "case", "0", ":", "break", ";", "default", ":", "LOSE_AND_RETURN", "(", "\"invalid operand modifier letter\"", ",", "x", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "operand", ")", ">", "MOXIE_R13", ")", "internal_error", "(", "\"internal error: bad register: %d\"", ",", "REGNO", "(", "operand", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "output_address", "(", "XEXP", "(", "operand", ",", "0", ")", ")", ";", "return", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "operand", ")", ")", "{", "output_addr_const", "(", "file", ",", "operand", ")", ";", "return", ";", "}", "LOSE_AND_RETURN", "(", "\"unexpected operand\"", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "The", "PRINT_OPERAND", "worker", "." ]

[ "moxie", "0", "\"invalid operand modifier letter\"", "\"internal error: bad register: %d\"", "\"%s\"", "0", "\"unexpected operand\"" ]

[]

[ "<s>", "bool", "AGCAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "Count", "%", "2", "!=", "0", ")", "return", "false", ";", "uint64_t", "NopCount", "=", "Count", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "NopCount", ";", "i", "++", ")", "AGCMCCodeEmitter", "::", "emitBitsWithParity", "(", "OS", ",", "0x3000", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "AGC", "AGC", "2", "0", "2", "0", "AGC", "0x3000" ]

[]

[ "<s>", "bool", "MipsMulMulBugFix", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "MipsInstrInfo", "&", "MipsII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "fixMulMulBB", "(", "MBB", ",", "MipsII", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"convert address space of alloca'ed memory to local\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"convert address space of alloca'ed memory to local\"" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "if", "(", "NextInstKind", "!=", "CurInstKind", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Instruction Type Switch\\n\"", ")", ";", "if", "(", "NextInstKind", "!=", "IDAlu", ")", "OccupedSlotsMask", "|=", "31", ";", "CurEmitted", "=", "0", ";", "CurInstKind", "=", "NextInstKind", ";", "}", "if", "(", "CurInstKind", "==", "IDAlu", ")", "{", "AluInstCount", "++", ";", "switch", "(", "getAluKind", "(", "SU", ")", ")", "{", "case", "AluT_XYZW", ":", "CurEmitted", "+=", "4", ";", "break", ";", "case", "AluDiscarded", ":", "break", ";", "default", ":", "{", "++", "CurEmitted", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "It", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_begin", "(", ")", ",", "E", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineOperand", "&", "MO", "=", "*", "It", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_LITERAL_X", ")", "++", "CurEmitted", ";", "}", "}", "}", "}", "else", "{", "++", "CurEmitted", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "CurEmitted", "<<", "\" Instructions Emitted in this clause\\n\"", ")", ";", "if", "(", "CurInstKind", "!=", "IDFetch", ")", "{", "MoveUnits", "(", "Pending", "[", "IDFetch", "]", ",", "Available", "[", "IDFetch", "]", ")", ";", "}", "else", "FetchInstCount", "++", ";", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "AMDGPU", "R600", "\"Instruction Type Switch\\n\"", "31", "0", "4", "AMDGPU::ALU_LITERAL_X", "\" Instructions Emitted in this clause\\n\"" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "unsigned", "Alignment", "=", "LI", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", "==", "0", ")", "Alignment", "=", "DL", ".", "getABITypeAlignment", "(", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "MI", ",", "OpNo", ",", "AddrOps", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "unsigned", "OperandNo", "=", "0", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "Result", "->", "operands_begin", "(", ")", ",", "E", "=", "Result", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "OperandNo", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "AM", ".", "IndexReg", ")", "continue", ";", "unsigned", "IndexReg", "=", "constrainOperandRegClass", "(", "Result", "->", "getDesc", "(", ")", ",", "MO", ".", "getReg", "(", ")", ",", "OperandNo", ")", ";", "if", "(", "IndexReg", "==", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(", "IndexReg", ")", ";", "}", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "FuncInfo", ".", "MBB", "->", "insert", "(", "FuncInfo", ".", "InsertPt", ",", "Result", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

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

[]

[ "<s>", "static", "int", "reg_push_size", "(", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "R0_REGNO", ":", "case", "R1_REGNO", ":", "return", "2", ";", "case", "R2_REGNO", ":", "case", "R3_REGNO", ":", "case", "FLG_REGNO", ":", "return", "2", ";", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "case", "FB_REGNO", ":", "case", "SP_REGNO", ":", "if", "(", "TARGET_A16", ")", "return", "2", ";", "else", "return", "3", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "How", "many", "bytes", "a", "register", "uses", "on", "stack", "when", "it", "'s", "pushed", ".", "We", "need", "to", "know", "this", "because", "the", "push", "opcode", "needs", "to", "explicitly", "indicate", "the", "size", "of", "the", "register", ",", "even", "though", "the", "name", "of", "the", "register", "already", "tells", "it", "that", ".", "Used", "by", "m32c_output_reg_", "{", "push", ",", "pop", "}", ",", "which", "is", "only", "used", "through", "calls", "to", "ASM_OUTPUT_REG_", "{", "PUSH", ",", "POP", "}", "." ]

[ "m32c", "2", "2", "2", "3" ]

[]

[ "<s>", "bool", "BlackfinAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'r'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Blackfin", "0", "1", "0", "0" ]

[]