Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindTy", "::", "Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "RI5CY" ]

[]

[ "<s>", "void", "NVPTXTTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "BaseT", "::", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "peeling", "transformation", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "if", "(", "EnableAtomicOptimizations", ")", "{", "addPass", "(", "createAMDGPUAtomicOptimizerPass", "(", ")", ")", ";", "}", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "addPass", "(", "createLCSSAPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "void", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", "=", "nullptr", ")", "const", "override", "{", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "SPIRV" ]

[]

[ "<s>", "void", "sparc_flat_expand_epilogue", "(", "bool", "for_eh", ")", "{", "HOST_WIDE_INT", "size", "=", "sparc_frame_size", ";", "if", "(", "sparc_n_global_fp_regs", ">", "0", ")", "emit_save_or_restore_global_fp_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", "-", "sparc_apparent_frame_size", ",", "SORR_RESTORE", ")", ";", "if", "(", "frame_pointer_needed", "&&", "!", "for_eh", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "hard_frame_pointer_rtx", ")", ";", "if", "(", "return_addr_reg_needed_p", "(", "sparc_leaf_function_p", ")", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "INCOMING_RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "if", "(", "sparc_save_local_in_regs_p", ")", "emit_save_or_restore_local_in_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", ",", "SORR_RESTORE", ")", ";", "if", "(", "size", "==", "0", "||", "for_eh", ")", ";", "else", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_frame_blockage", "(", ")", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_frame_blockage", "(", ")", ")", ";", "if", "(", "size", "<=", "4096", ")", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "size", ")", ")", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", ")", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "size", "-", "4096", ")", ")", ")", ";", "}", "else", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "reg", ",", "GEN_INT", "(", "size", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "reg", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "function", "epilogue", ",", "either", "normal", "or", "part", "of", "a", "sibcall", ".", "We", "emit", "all", "the", "instructions", "except", "the", "return", "or", "the", "call", "." ]

[ "sparc", "0", "1", "0", "1", "4096", "8192", "4096", "4096", "1" ]

[]

[ "<s>", "static", "bool", "mflip_mips16_use_mips16_p", "(", "tree", "decl", ")", "{", "const", "char", "*", "name", ";", "bool", "base_is_mips16", "=", "(", "mips_base_compression_flags", "&", "MASK_MIPS16", ")", "!=", "0", ";", "if", "(", "!", "DECL_NAME", "(", "decl", ")", ")", "return", "!", "base_is_mips16", ";", "if", "(", "!", "mflip_mips16_htab", ")", "mflip_mips16_htab", "=", "hash_map", "<", "nofree_string_hash", ",", "bool", ">", "::", "create_ggc", "(", "37", ")", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "bool", "existed", ";", "bool", "*", "slot", "=", "&", "mflip_mips16_htab", "->", "get_or_insert", "(", "name", ",", "&", "existed", ")", ";", "if", "(", "!", "existed", ")", "{", "mips16_flipper", "=", "!", "mips16_flipper", ";", "*", "slot", "=", "mips16_flipper", "?", "!", "base_is_mips16", ":", "base_is_mips16", ";", "}", "return", "*", "slot", ";", "}", "</s>" ]

[ "DECL", "is", "a", "function", "that", "needs", "a", "default", "``", "mips16", "''", "or", "``", "nomips16", "''", "attribute", "for", "-mflip-mips16", ".", "Return", "true", "if", "it", "should", "use", "``", "mips16", "''", "and", "false", "if", "it", "should", "use", "``", "nomips16", "''", "." ]

[ "mips", "0", "37" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

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

[]

[ "<s>", "int", "cr16_function_arg_regno_p", "(", "int", "n", ")", "{", "return", "(", "(", "n", "<=", "MAX_REG_FOR_PASSING_ARGS", ")", "&&", "(", "n", ">=", "MIN_REG_FOR_PASSING_ARGS", ")", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG_REGNO_P", "defined", "in", "cr16.h", ".", "Return", "nonzero", "if", "N", "is", "a", "register", "used", "for", "passing", "parameters", "." ]

[ "cr16" ]

[]

[ "<s>", "bool", "rs6000_emit_set_const", "(", "rtx", "dest", ",", "rtx", "source", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "temp", ",", "set", ";", "rtx_insn", "*", "insn", ";", "HOST_WIDE_INT", "c", ";", "gcc_checking_assert", "(", "CONST_INT_P", "(", "source", ")", ")", ";", "c", "=", "INTVAL", "(", "source", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "source", ")", ")", ";", "return", "true", ";", "case", "SImode", ":", "temp", "=", "!", "can_create_pseudo_p", "(", ")", "?", "dest", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "temp", ")", ",", "GEN_INT", "(", "c", "&", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IOR", "(", "SImode", ",", "copy_rtx", "(", "temp", ")", ",", "GEN_INT", "(", "c", "&", "0xffff", ")", ")", ")", ")", ";", "break", ";", "case", "DImode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "{", "rtx", "hi", ",", "lo", ";", "hi", "=", "operand_subword_force", "(", "copy_rtx", "(", "dest", ")", ",", "WORDS_BIG_ENDIAN", "==", "0", ",", "DImode", ")", ";", "lo", "=", "operand_subword_force", "(", "dest", ",", "WORDS_BIG_ENDIAN", "!=", "0", ",", "DImode", ")", ";", "emit_move_insn", "(", "hi", ",", "GEN_INT", "(", "c", ">>", "32", ")", ")", ";", "c", "=", "(", "(", "c", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "emit_move_insn", "(", "lo", ",", "GEN_INT", "(", "c", ")", ")", ";", "}", "else", "rs6000_emit_set_long_const", "(", "dest", ",", "c", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "GEN_INT", "(", "c", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "." ]

[ "rs6000", "0xffff", "0xffff", "0", "0", "32", "0xffffffff", "0x80000000", "0x80000000" ]

[]

[ "<s>", "static", "poly_uint16", "aarch64_convert_sve_vector_bits", "(", "aarch64_sve_vector_bits_enum", "value", ")", "{", "if", "(", "value", "==", "SVE_SCALABLE", "||", "value", "==", "SVE_128", ")", "return", "poly_uint16", "(", "2", ",", "2", ")", ";", "else", "return", "(", "int", ")", "value", "/", "64", ";", "}", "</s>" ]

[ "Return", "the", "VG", "value", "associated", "with", "-msve-vector-bits=", "value", "VALUE", "." ]

[ "aarch64", "2", "2", "64" ]

[]

[ "<s>", "static", "bool", "mips_hard_regno_mode_ok_p", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "CCV2mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "2", "==", "0", ")", ";", "if", "(", "mode", "==", "CCV4mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "4", "==", "0", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "ISA_HAS_8CC", "?", "ST_REG_P", "(", "regno", ")", ":", "regno", "==", "FPSW_REGNUM", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "mode", "!=", "CCFmode", "&&", "!", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "1", ")", "==", "0", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "(", "(", "(", "regno", "-", "FP_REG_FIRST", ")", "%", "MAX_FPRS_PER_FMT", ")", "==", "0", "||", "(", "MIN_FPRS_PER_FMT", "==", "1", "&&", "size", "<=", "UNITS_PER_FPREG", ")", ")", ")", "{", "if", "(", "TARGET_O32_FP64A_ABI", "&&", "size", "<=", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "mode", "==", "CCFmode", ")", "return", "!", "(", "TARGET_FLOATXX", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "if", "(", "TARGET_LOONGSON_VECTORS", "&&", "(", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "DImode", ")", ")", "return", "true", ";", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "if", "(", "ACC_REG_P", "(", "regno", ")", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "||", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", ")", "{", "if", "(", "MD_REG_P", "(", "regno", ")", ")", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", ")", "return", "regno", "==", "(", "size", "<=", "UNITS_PER_WORD", "?", "LO_REGNUM", ":", "MD_REG_FIRST", ")", ";", "}", "else", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", "&&", "(", "(", "regno", "-", "DSP_ACC_REG_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "true", ";", "}", "}", "if", "(", "ALL_COP_REG_P", "(", "regno", ")", ")", "return", "mclass", "==", "MODE_INT", "&&", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "regno", "==", "GOT_VERSION_REGNUM", ")", "return", "mode", "==", "SImode", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "mips_hard_regno_mode_ok", "." ]

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

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "bool", "MinOnly", "=", "Minimal", "||", "DisablePacketizer", "||", "!", "HST", ".", "usePackets", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ",", "MinOnly", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineBasicBlock", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "Begin", "=", "MB", ".", "begin", "(", ")", ",", "End", "=", "MB", ".", "end", "(", ")", ";", "while", "(", "Begin", "!=", "End", ")", "{", "MachineBasicBlock", "::", "iterator", "RB", "=", "Begin", ";", "while", "(", "RB", "!=", "End", "&&", "HII", "->", "isSchedulingBoundary", "(", "*", "RB", ",", "&", "MB", ",", "MF", ")", ")", "++", "RB", ";", "MachineBasicBlock", "::", "iterator", "RE", "=", "RB", ";", "while", "(", "RE", "!=", "End", "&&", "!", "HII", "->", "isSchedulingBoundary", "(", "*", "RE", ",", "&", "MB", ",", "MF", ")", ")", "++", "RE", ";", "if", "(", "RE", "!=", "End", ")", "++", "RE", ";", "if", "(", "RB", "!=", "End", ")", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "RB", ",", "RE", ")", ";", "Begin", "=", "RE", ";", "}", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SI Assign intrpolation registers\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Assign intrpolation registers\"" ]

[]

[ "<s>", "static", "void", "spu_option_override", "(", "void", ")", "{", "init_machine_status", "=", "spu_init_machine_status", ";", "if", "(", "!", "flag_unroll_loops", "&&", "!", "flag_peel_loops", ")", "maybe_set_param_value", "(", "PARAM_MAX_COMPLETELY_PEEL_TIMES", ",", "4", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "flag_omit_frame_pointer", "=", "1", ";", "if", "(", "align_functions", "<", "8", ")", "align_functions", "=", "8", ";", "spu_hint_dist", "=", "8", "*", "4", "-", "spu_max_nops", "*", "4", ";", "if", "(", "spu_hint_dist", "<", "0", ")", "spu_hint_dist", "=", "0", ";", "if", "(", "spu_fixed_range_string", ")", "fix_range", "(", "spu_fixed_range_string", ")", ";", "if", "(", "spu_arch_string", ")", "{", "if", "(", "strcmp", "(", "&", "spu_arch_string", "[", "0", "]", ",", "\"cell\"", ")", "==", "0", ")", "spu_arch", "=", "PROCESSOR_CELL", ";", "else", "if", "(", "strcmp", "(", "&", "spu_arch_string", "[", "0", "]", ",", "\"celledp\"", ")", "==", "0", ")", "spu_arch", "=", "PROCESSOR_CELLEDP", ";", "else", "error", "(", "\"bad value (%s) for -march= switch\"", ",", "spu_arch_string", ")", ";", "}", "if", "(", "spu_tune_string", ")", "{", "if", "(", "strcmp", "(", "&", "spu_tune_string", "[", "0", "]", ",", "\"cell\"", ")", "==", "0", ")", "spu_tune", "=", "PROCESSOR_CELL", ";", "else", "if", "(", "strcmp", "(", "&", "spu_tune_string", "[", "0", "]", ",", "\"celledp\"", ")", "==", "0", ")", "spu_tune", "=", "PROCESSOR_CELLEDP", ";", "else", "error", "(", "\"bad value (%s) for -mtune= switch\"", ",", "spu_tune_string", ")", ";", "}", "if", "(", "spu_arch", "==", "PROCESSOR_CELLEDP", ")", "{", "if", "(", "!", "(", "target_flags_explicit", "&", "MASK_SAFE_HINTS", ")", ")", "target_flags", "&=", "~", "MASK_SAFE_HINTS", ";", "}", "REAL_MODE_FORMAT", "(", "SFmode", ")", "=", "&", "spu_single_format", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "spu", "4", "1", "8", "8", "8", "4", "4", "0", "0", "0", "\"cell\"", "0", "0", "\"celledp\"", "0", "\"bad value (%s) for -march= switch\"", "0", "\"cell\"", "0", "0", "\"celledp\"", "0", "\"bad value (%s) for -mtune= switch\"" ]

[]

[ "<s>", "static", "bool", "rs6000_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "type", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "false", ";", "}", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "NULL", ",", "NULL", ")", ")", "return", "false", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "16", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "aix_struct_return", "||", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", "return", "true", ";", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_return_big_vectors", "=", "false", ";", "if", "(", "!", "warned_for_return_big_vectors", ")", "{", "warning", "(", "OPT_Wpsabi", ",", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_return_big_vectors", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "a", "nonzero", "value", "to", "say", "to", "return", "the", "function", "value", "in", "memory", ",", "just", "as", "large", "structures", "are", "always", "returned", ".", "TYPE", "will", "be", "the", "data", "type", "of", "the", "value", ",", "and", "FNTYPE", "will", "be", "the", "type", "of", "the", "function", "doing", "the", "returning", ",", "or", "@", "code", "{", "NULL", "}", "for", "libcalls", ".", "The", "AIX", "ABI", "for", "the", "RS/6000", "specifies", "that", "all", "structures", "are", "returned", "in", "memory", ".", "The", "Darwin", "ABI", "does", "the", "same", ".", "The", "SVR4", "ABI", "specifies", "that", "structures", "<", "=", "8", "bytes", "are", "returned", "in", "r3/r4", ",", "but", "a", "draft", "put", "them", "in", "memory", ",", "and", "GCC", "used", "to", "implement", "the", "draft", "instead", "of", "the", "final", "standard", ".", "Therefore", ",", "aix_struct_return", "controls", "this", "instead", "of", "DEFAULT_ABI", ";", "V.4", "targets", "needing", "backward", "compatibility", "can", "change", "DRAFT_V4_STRUCT_RET", "to", "override", "the", "default", ",", "and", "-m", "switches", "get", "the", "final", "word", ".", "See", "rs6000_override_options", "for", "more", "details", ".", "The", "PPC32", "SVR4", "ABI", "uses", "IEEE", "double", "extended", "for", "long", "double", ",", "if", "128-bit", "long", "double", "support", "is", "enabled", ".", "These", "values", "are", "returned", "in", "memory", ".", "int_size_in_bytes", "returns", "-1", "for", "variable", "size", "objects", ",", "which", "go", "in", "memory", "always", ".", "The", "cast", "to", "unsigned", "makes", "-1", ">", "8", "." ]

[ "powerpcspe", "0", "0", "16", "8", "16", "8", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"" ]

[]

[ "<s>", "static", "void", "initialize_aarch64_tls_size", "(", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "aarch64_tls_size", "==", "0", ")", "aarch64_tls_size", "=", "24", ";", "switch", "(", "opts", "->", "x_aarch64_cmodel_var", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "aarch64_tls_size", ">", "24", ")", "aarch64_tls_size", "=", "24", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "aarch64_tls_size", ">", "32", ")", "aarch64_tls_size", "=", "32", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "if", "(", "aarch64_tls_size", ">", "48", ")", "aarch64_tls_size", "=", "48", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "A", "checking", "mechanism", "for", "the", "implementation", "of", "the", "tls", "size", "." ]

[ "aarch64", "0", "24", "24", "24", "32", "32", "48", "48" ]

[]

[ "<s>", "static", "bool", "riscv_interrupt_type_p", "(", "tree", "type", ")", "{", "return", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", "!=", "NULL", ";", "}", "</s>" ]

[ "Return", "true", "if", "function", "TYPE", "is", "an", "interrupt", "function", "." ]

[ "riscv", "\"interrupt\"" ]

[]

[ "<s>", "rtx", "aarch64_expand_fcmla_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "int", "fcode", ")", "{", "int", "bcode", "=", "fcode", "-", "AARCH64_SIMD_FCMLA_LANEQ_BUILTIN_BASE", "-", "1", ";", "aarch64_fcmla_laneq_builtin_datum", "*", "d", "=", "&", "aarch64_fcmla_lane_builtin_data", "[", "bcode", "]", ";", "machine_mode", "quadmode", "=", "GET_MODE_2XWIDER_MODE", "(", "d", "->", "mode", ")", ".", "require", "(", ")", ";", "rtx", "op0", "=", "force_reg", "(", "d", "->", "mode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ")", ";", "rtx", "op1", "=", "force_reg", "(", "d", "->", "mode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ")", ";", "rtx", "op2", "=", "force_reg", "(", "quadmode", ",", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ")", ";", "tree", "tmp", "=", "CALL_EXPR_ARG", "(", "exp", ",", "3", ")", ";", "rtx", "lane_idx", "=", "expand_expr", "(", "tmp", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_INITIALIZER", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "lane_idx", ")", ")", "{", "error", "(", "\"%Kargument %d must be a constant immediate\"", ",", "exp", ",", "4", ")", ";", "return", "const0_rtx", ";", "}", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "quadmode", ")", ".", "to_constant", "(", ")", ";", "aarch64_simd_lane_bounds", "(", "lane_idx", ",", "0", ",", "nunits", "/", "2", ",", "exp", ")", ";", "int", "lane", "=", "INTVAL", "(", "lane_idx", ")", ";", "if", "(", "lane", "<", "nunits", "/", "4", ")", "op2", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "op2", ",", "quadmode", ",", "subreg_lowpart_offset", "(", "d", "->", "mode", ",", "quadmode", ")", ")", ";", "else", "{", "rtx", "temp1", "=", "gen_reg_rtx", "(", "d", "->", "mode", ")", ";", "rtx", "temp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "temp1", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "op2", ",", "quadmode", ",", "subreg_lowpart_offset", "(", "d", "->", "mode", ",", "quadmode", ")", ")", ";", "temp1", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "temp1", ",", "d", "->", "mode", ",", "0", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_aarch64_get_lanev2di", "(", "temp2", ",", "temp1", ",", "const0_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_aarch64_get_lanev2di", "(", "temp2", ",", "temp1", ",", "const1_rtx", ")", ")", ";", "op2", "=", "simplify_gen_subreg", "(", "d", "->", "mode", ",", "temp2", ",", "GET_MODE", "(", "temp2", ")", ",", "0", ")", ";", "lane", "-=", "nunits", "/", "4", ";", "}", "lane_idx", "=", "aarch64_endian_lane_rtx", "(", "V2DImode", ",", "lane", ")", ";", "if", "(", "!", "target", "||", "!", "REG_P", "(", "target", ")", "||", "GET_MODE", "(", "target", ")", "!=", "d", "->", "mode", ")", "target", "=", "gen_reg_rtx", "(", "d", "->", "mode", ")", ";", "rtx", "pat", "=", "NULL_RTX", ";", "if", "(", "d", "->", "lane", ")", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ",", "lane_idx", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "FCMLA", "lane", "expression", "EXP", "with", "code", "FCODE", "and", "result", "going", "to", "TARGET", "if", "that", "is", "convenient", "." ]

[ "aarch64", "1", "0", "1", "2", "3", "\"%Kargument %d must be a constant immediate\"", "4", "0", "2", "4", "0", "0", "4" ]

[]

[ "<s>", "void", "RISCVConstantPoolValue", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "O", "<<", "GV", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "rtx", "frv_dwarf_store", "(", "rtx", "reg", ",", "int", "offset", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "offset", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Generate", "a", "frame-related", "expression", ":", "(", "set", "REG", "(", "mem", "(", "plus", "(", "sp", ")", "(", "const_int", "OFFSET", ")", ")", ")", ")", ".", "Such", "expressions", "are", "used", "in", "FRAME_RELATED_EXPR", "notes", "for", "more", "complex", "instructions", ".", "Marking", "the", "expressions", "as", "frame-related", "is", "superfluous", "if", "the", "note", "contains", "just", "a", "single", "set", ".", "But", "if", "the", "note", "contains", "a", "PARALLEL", "or", "SEQUENCE", "that", "has", "several", "sets", ",", "each", "set", "must", "be", "individually", "marked", "as", "frame-related", "." ]

[ "frv", "1" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "4", ";", "return", "1", ";", "}", "--", "I", ";", "if", "(", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "4", ";", "return", "1", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "8", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "AArch64", "AArch64", "0", "0", "4", "1", "4", "1", "8", "2" ]

[]

[ "<s>", "unsigned", "int", "pass_s390_early_mach", "::", "execute", "(", "function", "*", "fun", ")", "{", "rtx_insn", "*", "insn", ";", "s390_optimize_nonescaping_tx", "(", ")", ";", "s390_register_info", "(", ")", ";", "if", "(", "fun", "->", "machine", "->", "base_reg", ")", "emit_insn_at_entry", "(", "gen_main_pool", "(", "fun", "->", "machine", "->", "base_reg", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "annotate_constant_pool_refs", "(", "&", "PATTERN", "(", "insn", ")", ")", ";", "df_insn_rescan", "(", "insn", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "s390", "0" ]

[]

[ "<s>", "BitVector", "TeeRISCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "TeeRISC", "::", "R0", ",", "TeeRISC", "::", "R1", ",", "TeeRISC", "::", "R14", ",", "TeeRISC", "::", "R15", ",", "TeeRISC", "::", "R16", ",", "TeeRISC", "::", "R17", ",", "TeeRISC", "::", "R18", ",", "TeeRISC", "::", "R19", ",", "TeeRISC", "::", "R20", ",", "TeeRISC", "::", "R21", ",", "TeeRISC", "::", "R22", ",", "TeeRISC", "::", "R23", ",", "TeeRISC", "::", "R24", ",", "TeeRISC", "::", "R25", ",", "TeeRISC", "::", "R26", ",", "TeeRISC", "::", "R27", ",", "TeeRISC", "::", "R28", ",", "TeeRISC", "::", "R29", ",", "TeeRISC", "::", "R30", ",", "TeeRISC", "::", "R31", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "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", "." ]

[ "TeeRISC", "TeeRISC", "TeeRISC::R0", "TeeRISC::R1", "TeeRISC::R14", "TeeRISC::R15", "TeeRISC::R16", "TeeRISC::R17", "TeeRISC::R18", "TeeRISC::R19", "TeeRISC::R20", "TeeRISC::R21", "TeeRISC::R22", "TeeRISC::R23", "TeeRISC::R24", "TeeRISC::R25", "TeeRISC::R26", "TeeRISC::R27", "TeeRISC::R28", "TeeRISC::R29", "TeeRISC::R30", "TeeRISC::R31", "0" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "Mips", "0" ]

[]

[ "<s>", "void", "ARMELFStreamer", "::", "EmitRegSave", "(", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "RegList", ",", "bool", "IsVector", ")", "{", "unsigned", "Count", "=", "0", ";", "uint32_t", "Mask", "=", "0", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "RegList", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "MRI", "->", "getEncodingValue", "(", "RegList", "[", "i", "]", ")", ";", "assert", "(", "Reg", "<", "(", "IsVector", "?", "32U", ":", "16U", ")", "&&", "\"Register out of range\"", ")", ";", "unsigned", "Bit", "=", "(", "1u", "<<", "Reg", ")", ";", "if", "(", "(", "Mask", "&", "Bit", ")", "==", "0", ")", "{", "Mask", "|=", "Bit", ";", "++", "Count", ";", "}", "}", "SPOffset", "-=", "Count", "*", "(", "IsVector", "?", "8", ":", "4", ")", ";", "FlushPendingOffset", "(", ")", ";", "if", "(", "IsVector", ")", "UnwindOpAsm", ".", "EmitVFPRegSave", "(", "Mask", ")", ";", "else", "UnwindOpAsm", ".", "EmitRegSave", "(", "Mask", ")", ";", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "for", ".save", "directives", "." ]

[ "ARM", "ARM", "0", "0", "0", "32U", "16U", "\"Register out of range\"", "1u", "0", "8", "4" ]

[]

[ "<s>", "static", "void", "rx_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "addr", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"[-\"", ")", ";", "rx_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"+]\"", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg2", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "rtx", "base", ",", "index", ";", "if", "(", "REG_P", "(", "arg1", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg1", ",", "true", ")", ")", "base", "=", "arg1", ",", "index", "=", "arg2", ";", "else", "if", "(", "REG_P", "(", "arg2", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg2", ",", "true", ")", ")", "base", "=", "arg2", ",", "index", "=", "arg1", ";", "else", "{", "rx_print_operand", "(", "file", ",", "arg1", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\" + \"", ")", ";", "rx_print_operand", "(", "file", ",", "arg2", ",", "0", ")", ";", "break", ";", "}", "if", "(", "REG_P", "(", "index", ")", "||", "GET_CODE", "(", "index", ")", "==", "MULT", ")", "{", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "rx_print_operand", "(", "file", ",", "index", ",", "'A'", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "}", "else", "{", "rx_print_operand", "(", "file", ",", "index", ",", "'A'", ")", ";", "fprintf", "(", "file", ",", "\"[\"", ")", ";", "}", "rx_print_operand", "(", "file", ",", "base", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"]\"", ")", ";", "break", ";", "}", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_CONST", ")", ";", "addr", "=", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "addr", ")", ")", ";", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "case", "UNSPEC", ":", "addr", "=", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "A", "C", "compound", "statement", "to", "output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", "." ]

[ "rx", "\"[\"", "0", "\"]\"", "\"[-\"", "0", "0", "\"]\"", "\"[\"", "0", "0", "\"+]\"", "0", "1", "0", "\" + \"", "0", "\"[\"", "\",\"", "\"[\"", "0", "\"]\"", "0", "0", "1", "0", "0", "\"#\"", "\"#\"", "0", "0", "0", "\"#\"" ]

[]

[ "<s>", "void", "xstormy16_expand_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "rtx", "dest_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "dest_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "dest_reg", ",", "dest_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "dest", "=", "gen_rtx_MEM", "(", "mode", ",", "dest_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "src_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "src_reg", ",", "src_mod", ")", ";", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "src", "=", "gen_rtx_MEM", "(", "mode", ",", "src_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "MEM_P", "(", "dest", ")", "&&", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "||", "!", "xstormy16_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "dest", ",", "0", ")", ",", "0", ")", ")", "&&", "!", "xstormy16_below100_operand", "(", "dest", ",", "mode", ")", "&&", "!", "REG_P", "(", "src", ")", "&&", "GET_CODE", "(", "src", ")", "!=", "SUBREG", ")", "src", "=", "copy_to_mode_reg", "(", "mode", ",", "src", ")", ";", "if", "(", "reload_completed", "&&", "mode", "!=", "HImode", "&&", "mode", "!=", "QImode", ")", "{", "xstormy16_split_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "return", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "the", "'move", "'", "patterns", ".", "Emit", "insns", "to", "copy", "a", "value", "of", "mode", "MODE", "from", "SRC", "to", "DEST", "." ]

[ "stormy16", "0", "0", "0", "1", "2", "0", "0", "0", "1", "2", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "save_fpr", "(", "rtx", "base", ",", "int", "offset", ",", "int", "regnum", ")", "{", "rtx", "addr", ";", "addr", "=", "gen_rtx_MEM", "(", "DFmode", ",", "plus_constant", "(", "base", ",", "offset", ")", ")", ";", "if", "(", "regnum", ">=", "16", "&&", "regnum", "<=", "(", "16", "+", "FP_ARG_NUM_REG", ")", ")", "set_mem_alias_set", "(", "addr", ",", "get_varargs_alias_set", "(", ")", ")", ";", "else", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "return", "emit_move_insn", "(", "addr", ",", "gen_rtx_REG", "(", "DFmode", ",", "regnum", ")", ")", ";", "}", "</s>" ]

[ "Emit", "insn", "to", "save", "fpr", "REGNUM", "at", "offset", "OFFSET", "relative", "to", "register", "BASE", ".", "Return", "generated", "insn", "." ]

[ "s390", "16", "16" ]

[]

[ "<s>", "bool", "MipsExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "if", "(", "Modified", ")", "MF", ".", "RenumberBlocks", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "string", "AMDGPUSIDevice", "::", "getDataLayout", "(", ")", "const", "{", "return", "std", "::", "string", "(", "\"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n8:16:32:64\"", ")", ";", "}", "</s>" ]

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

[ "R600", "AMDGPUSIDevice::getDataLayout", "\"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n8:16:32:64\"" ]

[]

[ "<s>", "static", "std", "::", "string", "getGraphName", "(", "const", "ScheduleDAG", "*", "G", ")", "{", "return", "G", "->", "MF", ".", "getName", "(", ")", ";", "}", "</s>" ]

[ "Generate", "a", "title", "for", "the", "graph", "in", "DOT", "format", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isLdStPairSuppressed", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "assert", "(", "MOSuppressPair", "<", "(", "1", "<<", "MachineMemOperand", "::", "MOTargetNumBits", ")", "&&", "\"Too many target MO flags\"", ")", ";", "for", "(", "auto", "*", "MM", ":", "MI", "->", "memoperands", "(", ")", ")", "{", "if", "(", "MM", "->", "getFlags", "(", ")", "&", "(", "MOSuppressPair", "<<", "MachineMemOperand", "::", "MOTargetStartBit", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "is", "hinted", "to", "be", "unprofitable", "." ]

[ "AArch64", "AArch64", "1", "\"Too many target MO flags\"" ]

[]

[ "<s>", "bool", "X86FrameInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isWin64", "=", "STI", ".", "isTargetWin64", "(", ")", ";", "unsigned", "SlotSize", "=", "STI", ".", "is64Bit", "(", ")", "?", "8", ":", "4", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "if", "(", "!", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "isWin64", ")", "{", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "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", "(", ")", "." ]

[ "X86", "X86", "8", "4", "0", "X86", "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::VR128RegClass", "1", "X86" ]

[]

[ "<s>", "static", "void", "riscv_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "struct", "riscv_address_info", "addr", ";", "if", "(", "riscv_classify_address", "(", "&", "addr", ",", "x", ",", "word_mode", ",", "true", ")", ")", "switch", "(", "addr", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "riscv_print_operand", "(", "file", ",", "addr", ".", "offset", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_LO_SUM", ":", "riscv_print_operand_reloc", "(", "file", ",", "addr", ".", "offset", ",", "false", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_CONST_INT", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "GP_REG_FIRST", "]", ")", ";", "return", ";", "case", "ADDRESS_SYMBOLIC", ":", "output_addr_const", "(", "file", ",", "riscv_strip_unspec_address", "(", "x", ")", ")", ";", "return", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "riscv", "0", "\"(%s)\"", "\"(%s)\"", "\"(%s)\"" ]

[]

[ "<s>", "bool", "ELFAArch64AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "ix86_expand_floorceildf_32", "(", "rtx", "operand0", ",", "rtx", "operand1", ",", "bool", "do_floor", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "TWO52", ",", "tmp", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "copy_to_reg", "(", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa", ",", "TWO52", ",", "xa", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "ix86_sse_copysign_to_positive", "(", "xa", ",", "xa", ",", "res", ",", "mask", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconst1", ",", "mode", ")", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "xa", ",", "res", ",", "!", "do_floor", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "one", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "do_floor", "?", "MINUS", ":", "PLUS", ",", "xa", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "HONOR_SIGNED_ZEROS", "(", "mode", ")", ")", "{", "if", "(", "do_floor", "&&", "flag_rounding_math", ")", "tmp", "=", "ix86_expand_sse_fabs", "(", "tmp", ",", "NULL", ")", ";", "ix86_sse_copysign_to_positive", "(", "tmp", ",", "tmp", ",", "res", ",", "mask", ")", ";", "}", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE2", "sequence", "for", "computing", "floor", "or", "ceil", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

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

[]

[ "<s>", "bool", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "Mask", ",", "EVT", "VT", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "bool", "offsettable_ok_by_alignment", "(", "rtx", "op", ",", "HOST_WIDE_INT", "offset", ",", "machine_mode", "mode", ")", "{", "tree", "decl", ";", "unsigned", "HOST_WIDE_INT", "dsize", ",", "dalign", ",", "lsb", ",", "mask", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "if", "(", "mode_supports_vsx_dform_quad", "(", "mode", ")", ")", "return", "false", ";", "dsize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "if", "(", "!", "decl", ")", "{", "if", "(", "dsize", "==", "0", ")", "return", "false", ";", "dalign", "=", "BITS_PER_UNIT", ";", "if", "(", "SYMBOL_REF_HAS_BLOCK_INFO_P", "(", "op", ")", "&&", "SYMBOL_REF_ANCHOR_P", "(", "op", ")", "&&", "SYMBOL_REF_BLOCK", "(", "op", ")", "!=", "NULL", ")", "{", "struct", "object_block", "*", "block", "=", "SYMBOL_REF_BLOCK", "(", "op", ")", ";", "dalign", "=", "block", "->", "alignment", ";", "offset", "+=", "SYMBOL_REF_BLOCK_OFFSET", "(", "op", ")", ";", "}", "else", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "op", ")", ")", "{", "machine_mode", "cmode", "=", "get_pool_mode", "(", "op", ")", ";", "dalign", "=", "GET_MODE_ALIGNMENT", "(", "cmode", ")", ";", "}", "}", "else", "if", "(", "DECL_P", "(", "decl", ")", ")", "{", "dalign", "=", "DECL_ALIGN", "(", "decl", ")", ";", "if", "(", "dsize", "==", "0", ")", "{", "if", "(", "!", "DECL_SIZE_UNIT", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "DECL_SIZE_UNIT", "(", "decl", ")", ")", ")", "return", "false", ";", "dsize", "=", "tree_to_uhwi", "(", "DECL_SIZE_UNIT", "(", "decl", ")", ")", ";", "if", "(", "dsize", ">", "32768", ")", "return", "false", ";", "dalign", "/=", "BITS_PER_UNIT", ";", "if", "(", "dalign", ">", "POWERPC64_TOC_POINTER_ALIGNMENT", ")", "dalign", "=", "POWERPC64_TOC_POINTER_ALIGNMENT", ";", "return", "dalign", ">=", "dsize", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "dalign", "/=", "BITS_PER_UNIT", ";", "if", "(", "dalign", ">", "POWERPC64_TOC_POINTER_ALIGNMENT", ")", "dalign", "=", "POWERPC64_TOC_POINTER_ALIGNMENT", ";", "mask", "=", "dalign", "-", "1", ";", "lsb", "=", "offset", "&", "-", "offset", ";", "mask", "&=", "lsb", "-", "1", ";", "dalign", "=", "mask", "+", "1", ";", "return", "dalign", ">=", "dsize", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "MODE", "sized", "memory", "accesses", "to", "OP", "plus", "OFFSET", "is", "known", "to", "not", "straddle", "a", "32k", "boundary", "." ]

[ "powerpcspe", "0", "0", "32768", "1", "1", "1" ]

[]

[ "<s>", "update_cc", "(", "BODY", ",", "INSN", ")", "{", "const", "char", "*", "p", ";", "\\", "\\", "fprintf", "(", "FILE", ",", "\"\\t.globl .oVncs\\n\\t.set .oVncs,0\\n\"", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"\\t.globl .oVgcc\"", ")", ";", "\\", "for", "(", "p", "=", "version_string", ";", "*", "p", "!=", "' '", "&&", "*", "p", "!=", "0", ";", "p", "++", ")", "\\", "fprintf", "(", "FILE", ",", "\"%c\"", ",", "*", "p", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"\\n\\t.set .oVgcc\"", ")", ";", "\\", "for", "(", "p", "=", "version_string", ";", "*", "p", "!=", "' '", "&&", "*", "p", "!=", "0", ";", "p", "++", ")", "\\", "fprintf", "(", "FILE", ",", "\"%c\"", ",", "*", "p", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\",0\\n\"", ")", ";", "\\", "}", "</s>" ]

[ "Update", "the", "condition", "code", "from", "the", "insn", ".", "Look", "mostly", "at", "the", "first", "byte", "of", "the", "machine-specific", "insn", "description", "information", ".", "cc_state.value", "[", "12", "]", "refer", "to", "two", "possible", "values", "that", "might", "correspond", "to", "the", "CC", ".", "We", "only", "store", "register", "values", "." ]

[ "romp", "\"\\t.globl .oVncs\\n\\t.set .oVncs,0\\n\"", "\"\\t.globl .oVgcc\"", "0", "\"%c\"", "\"\\n\\t.set .oVgcc\"", "0", "\"%c\"", "\",0\\n\"" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "reduceLoopCount", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "PreHeader", ",", "MachineInstr", "*", "IndVar", ",", "MachineInstr", "&", "Cmp", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "PrevInsts", ",", "unsigned", "Iter", ",", "unsigned", "MaxIter", ")", "const", "{", "assert", "(", "(", "!", "IndVar", ")", "&&", "isBDNZ", "(", "Cmp", ".", "getOpcode", "(", ")", ")", "&&", "\"Expecting a CTR loop\"", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "PreHeader", ")", ";", "if", "(", "!", "Loop", ")", "return", "0", ";", "unsigned", "LoopCountReg", "=", "Loop", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "LoopCount", "=", "MRI", ".", "getUniqueVRegDef", "(", "LoopCountReg", ")", ";", "if", "(", "!", "LoopCount", ")", "return", "0", ";", "if", "(", "LoopCount", "->", "getOpcode", "(", ")", "==", "PPC", "::", "LI8", "||", "LoopCount", "->", "getOpcode", "(", ")", "==", "PPC", "::", "LI", ")", "{", "int64_t", "Offset", "=", "LoopCount", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "1", ")", "{", "LoopCount", "->", "eraseFromParent", "(", ")", ";", "Loop", "->", "eraseFromParent", "(", ")", ";", "return", "0", ";", "}", "LoopCount", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "Offset", "-", "1", ")", ";", "return", "Offset", "-", "1", ";", "}", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "CTR8", ":", "PPC", "::", "CTR", ",", "true", ")", ")", ";", "return", "LoopCountReg", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Expecting a CTR loop\"", "0", "0", "0", "PPC::LI8", "PPC::LI", "1", "1", "0", "1", "1", "1", "0", "PPC", "PPC::CTR8", "PPC::CTR" ]

[]

[ "<s>", "bool", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "MOS" ]

[]

[ "<s>", "void", "print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "letter", ")", "{", "register", "enum", "rtx_code", "code", ";", "if", "(", "!", "x", ")", "{", "error", "(", "\"PRINT_OPERAND null pointer\"", ")", ";", "return", ";", "}", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "SIGN_EXTEND", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ",", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "letter", "==", "'C'", "||", "letter", "==", "'N'", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "fputs", "(", "\"eq\"", ",", "file", ")", ";", "return", ";", "case", "NE", ":", "fputs", "(", "\"ne\"", ",", "file", ")", ";", "return", ";", "case", "GT", ":", "fputs", "(", "\"gt\"", ",", "file", ")", ";", "return", ";", "case", "GE", ":", "fputs", "(", "\"ge\"", ",", "file", ")", ";", "return", ";", "case", "LT", ":", "fputs", "(", "\"lt\"", ",", "file", ")", ";", "return", ";", "case", "LE", ":", "fputs", "(", "\"le\"", ",", "file", ")", ";", "return", ";", "case", "GTU", ":", "fputs", "(", "\"gtu\"", ",", "file", ")", ";", "return", ";", "case", "GEU", ":", "fputs", "(", "\"geu\"", ",", "file", ")", ";", "return", ";", "case", "LTU", ":", "fputs", "(", "\"ltu\"", ",", "file", ")", ";", "return", ";", "case", "LEU", ":", "fputs", "(", "\"leu\"", ",", "file", ")", ";", "return", ";", "default", ":", "abort_with_insn", "(", "x", ",", "\"PRINT_OPERAND, invalid insn for %%C\"", ")", ";", "}", "return", ";", "}", "if", "(", "code", "==", "REG", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "letter", "==", "'D'", ")", "regno", "++", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "regno", "]", ")", ";", "return", ";", "}", "if", "(", "code", "==", "MEM", ")", "{", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "code", "==", "CONST_INT", "||", "code", "==", "CONST_DOUBLE", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "REAL_VALUE_TYPE", "d", ";", "long", "l", ";", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "d", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "d", ",", "l", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "l", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t; %.12g\"", ",", "d", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "}", "</s>" ]

[ "Use", "S", "for", "SI", "regsUse", "B", "&", "T", "for", "parts", "of", "DI", "regs", "X", "-", "stack", "pointer", "name", "Registers", "Q", "-", "byte", "sized", "register", "name", "U", "-", "high", "byte", "of", "word", "register", "V", "-", "low", "byte", "of", "word", "register", "H", "-", "word", "register", "name", "I", "-", "next", "word", "register", "name", "S", "&", "B", "-", "long", "register", "name", "T", "-", "next", "long", "register", "name", "D", "-", "quad", "register", "name", "P", "-", "register", "name", "in", "size", "of", "pointer", "Integers", "O", "-", "log", "two", "of", "value", "P", "-", "inverted", "log", "two", "H", "-", "bottom", "16", "bits", "I", "-", "top", "16", "bits", "N", "-", "negative", "B", "-", "high", "32", "bits", "of", "32bit", "number", ".", "default", ":", "value", "Memory", "I", "-", "adjusted", "upwards", "by", "two", "T", "-", "adjusted", "upwards", "by", "four", "default", ":", "value", "Address", "H", "-", "low", "16", "bits", "I", "-", "high", "16", "bits", "A", "-", "as", "long", "constant", "S", "-", "as", "A", "but", "with", "#", "default", ":", "error", "Misc", "C", "-", "conditional", "name", "D", "-", "reverse", "conditional", "name", "F", "-", "clear", "v", "flag", "if", "necessary" ]

[ "mapip", "\"PRINT_OPERAND null pointer\"", "0", "\"eq\"", "\"ne\"", "\"gt\"", "\"ge\"", "\"lt\"", "\"le\"", "\"gtu\"", "\"geu\"", "\"ltu\"", "\"leu\"", "\"PRINT_OPERAND, invalid insn for %%C\"", "\"%s\"", "0", "\"#\"", "\"\\t\\t; %.12g\"", "\"#\"", "\"#\"" ]

[]

[ "<s>", "static", "uint8_t", "name", "(", "struct", "InternalInstruction", "*", "insn", ",", "\\", "OperandType", "type", ",", "\\", "uint8_t", "index", ",", "\\", "uint8_t", "*", "valid", ")", "{", "\\", "*", "valid", "=", "1", ";", "\\", "switch", "(", "type", ")", "{", "\\", "default", ":", "\\", "debug", "(", "\"Unhandled register type\"", ")", ";", "\\", "*", "valid", "=", "0", ";", "\\", "return", "0", ";", "\\", "case", "TYPE_Rv", ":", "\\", "return", "base", "+", "index", ";", "\\", "case", "TYPE_R8", ":", "\\", "if", "(", "insn", "->", "rexPrefix", "&&", "\\", "index", ">=", "4", "&&", "index", "<=", "7", ")", "{", "\\", "return", "prefix", "##", "_SPL", "+", "(", "index", "-", "4", ")", ";", "\\", "}", "else", "{", "\\", "return", "prefix", "##", "_AL", "+", "index", ";", "\\", "}", "\\", "case", "TYPE_R16", ":", "\\", "return", "prefix", "##", "_AX", "+", "index", ";", "\\", "case", "TYPE_R32", ":", "\\", "return", "prefix", "##", "_EAX", "+", "index", ";", "\\", "case", "TYPE_R64", ":", "\\", "return", "prefix", "##", "_RAX", "+", "index", ";", "\\", "case", "TYPE_XMM512", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "case", "TYPE_XMM256", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_XMM128", ":", "\\", "case", "TYPE_XMM64", ":", "\\", "case", "TYPE_XMM32", ":", "\\", "case", "TYPE_XMM", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_VK1", ":", "\\", "case", "TYPE_VK2", ":", "\\", "case", "TYPE_VK4", ":", "\\", "case", "TYPE_VK8", ":", "\\", "case", "TYPE_VK16", ":", "\\", "case", "TYPE_VK32", ":", "\\", "case", "TYPE_VK64", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_K0", "+", "index", ";", "\\", "case", "TYPE_MM64", ":", "\\", "return", "prefix", "##", "_MM0", "+", "(", "index", "&", "0x7", ")", ";", "\\", "case", "TYPE_SEGMENTREG", ":", "\\", "if", "(", "index", ">", "5", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_ES", "+", "index", ";", "\\", "case", "TYPE_DEBUGREG", ":", "\\", "return", "prefix", "##", "_DR0", "+", "index", ";", "\\", "case", "TYPE_CONTROLREG", ":", "\\", "return", "prefix", "##", "_CR0", "+", "index", ";", "\\", "}", "\\", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "X86", "1", "\"Unhandled register type\"", "0", "0", "4", "7", "4", "7", "0", "0x7", "5", "0" ]

[]

[ "<s>", "static", "inline", "bool", "inline_secondary_memory_needed", "(", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ",", "machine_mode", "mode", ",", "int", "strict", ")", "{", "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class1", ")", "||", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class1", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class2", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class1", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class2", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class1", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class2", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "{", "gcc_assert", "(", "!", "strict", "||", "lra_in_progress", ")", ";", "return", "true", ";", "}", "if", "(", "FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "(", "MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", ")", "return", "true", ";", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "TARGET_SSE2", ")", "return", "true", ";", "if", "(", "(", "SSE_CLASS_P", "(", "class1", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "||", "(", "SSE_CLASS_P", "(", "class2", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "To", "optimize", "register_move_cost", "performance", ",", "allow", "inline", "variant", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "void", "SPUFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "Align", "=", "std", "::", "max", "(", "TargetAlign", ",", "MFI", "->", "getMaxAlignment", "(", ")", ")", ";", "assert", "(", "isPowerOf2_32", "(", "Align", ")", "&&", "\"Alignment is not power of 2\"", ")", ";", "unsigned", "AlignMask", "=", "Align", "-", "1", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "CellSPU", "SPU", "\"Alignment is not power of 2\"", "1" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MOVCCr", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2MOVCCr", ")", "&&", "\"Unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "2", ":", "1", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "add", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "ARMCC", "::", "CondCodes", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "add", "(", "MI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "NewMI", "->", "hasOptionalDef", "(", ")", ")", "NewMI", ".", "add", "(", "condCodeOp", "(", ")", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "add", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "\"Unknown select instruction\"", "2", "1", "2", "1", "0", "1", "3", "ARMCC::getOppositeCondition", "ARMCC::CondCodes", "4", "0", "1" ]

[]

[ "<s>", "bool", "MOSMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "const", "MOSRegisterInfo", "&", "TRI", "=", "*", "MO", ".", "getParent", "(", ")", "->", "getMF", "(", ")", "->", "getSubtarget", "<", "MOSSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Operand: \"", "<<", "MO", "<<", "\"\\n\"", ")", ";", "report_fatal_error", "(", "\"Operand type not implemented.\"", ")", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "AP", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "AP", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "AP", ".", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "MOSAsmBackend", "::", "isZeroPageSectionName", "(", "GV", "->", "getSection", "(", ")", ")", ")", "{", "const", "MOSMCExpr", "*", "Expr", "=", "MOSMCExpr", "::", "create", "(", "MOSMCExpr", "::", "VK_MOS_ADDR8", ",", "MCOp", ".", "getExpr", "(", ")", ",", "false", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "}", "break", ";", "}", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "{", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "AP", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MOS", "::", "Imag16RegClass", ".", "contains", "(", "Reg", ")", "||", "MOS", "::", "Imag8RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Ctx", ".", "getOrCreateSymbol", "(", "TRI", ".", "getImag8SymbolName", "(", "Reg", ")", ")", ",", "Ctx", ")", ";", "Expr", "=", "MOSMCExpr", "::", "create", "(", "MOSMCExpr", "::", "VK_MOS_ADDR8", ",", "Expr", ",", "false", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "}", "else", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "MOS", "MOS", "MOS", "MOS", "\"Operand: \"", "\"\\n\"", "\"Operand type not implemented.\"", "MOS", "MOS", "MOS", "MOS", "MOS", "MOS::Imag16RegClass", "MOS::Imag8RegClass", "MOS", "MOS", "MOS" ]

[]

[ "<s>", "tree", "ix86_handle_selectany_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", "&&", "TREE_PUBLIC", "(", "*", "node", ")", "&&", "(", "DECL_INITIAL", "(", "*", "node", ")", "||", "TYPE_NEEDS_CONSTRUCTING", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "make_decl_one_only", "(", "*", "node", ")", ";", "else", "{", "error", "(", "\"%qs attribute applies only to initialized variables\"", "\" with external linkage\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

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

[ "i386", "\"%qs attribute applies only to initialized variables\"", "\" with external linkage\"" ]

[]

[ "<s>", "void", "rs6000_sibcall_aix", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "flag", ",", "rtx", "cookie", ")", "{", "rtx", "call", "[", "2", "]", ";", "rtx", "insn", ";", "gcc_assert", "(", "INTVAL", "(", "cookie", ")", "==", "0", ")", ";", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_desc", ")", ",", "flag", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "value", ",", "call", "[", "0", "]", ")", ";", "call", "[", "1", "]", "=", "simple_return_rtx", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "2", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGNUM", ")", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ")", ";", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "sibling", "call", "under", "the", "AIX", "or", "ELFv2", "ABI", "." ]

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

[]

[ "<s>", "void", "LC2200FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "LC2200InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "Register", "FPReg", "=", "LC2200", "::", "fp", ";", "Register", "SPReg", "=", "LC2200", "::", "sp", ";", "auto", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "StackSize", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "auto", "&", "I", "=", "LastFrameDestroy", ";", "I", "!=", "MBBI", ";", "++", "I", ")", "{", "if", "(", "I", "->", "mayLoad", "(", ")", "&&", "I", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", ")", "{", "Register", "DestReg", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "DestReg", "==", "FPReg", ")", "{", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "SPReg", ",", "true", ")", ",", "-", "FPOffset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "break", ";", "}", "}", "}", "}", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "Register", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200", "LC2200", "LC2200::fp", "LC2200::sp", "\"frame pointer should not have been eliminated\"", "0", "0", "0" ]

[]

[ "<s>", "void", "add_input_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "create_input_operand", "(", "&", "m_ops", "[", "m_opno", "++", "]", ",", "x", ",", "mode", ")", ";", "gcc_assert", "(", "m_opno", "<=", "MAX_OPERANDS", ")", ";", "}", "</s>" ]

[ "Create", "op", "and", "add", "it", "into", "M_OPS", "and", "increase", "OPNO", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_or_conds", "(", "rtx", "target", ",", "rtx_code", "code1", ",", "rtx_code", "code2", ",", "rtx", "ptrue", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "ptrue", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_sve_ptrue_op", "(", "tmp1", ",", "ptrue", ",", "gen_rtx_fmt_ee", "(", "code1", ",", "pred_mode", ",", "op0", ",", "op1", ")", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_sve_ptrue_op", "(", "tmp2", ",", "ptrue", ",", "gen_rtx_fmt_ee", "(", "code2", ",", "pred_mode", ",", "op0", ",", "op1", ")", ")", ";", "aarch64_emit_binop", "(", "target", ",", "ior_optab", ",", "tmp1", ",", "tmp2", ")", ";", "}", "</s>" ]

[ "Emit", "the", "SVE", "equivalent", "of", ":", "(", "set", "TMP1", "(", "CODE1", "OP0", "OP1", ")", ")", "(", "set", "TMP2", "(", "CODE2", "OP0", "OP1", ")", ")", "(", "set", "TARGET", "(", "ior", ":", "PRED_MODE", "TMP1", "TMP2", ")", ")", "PTRUE", "is", "an", "all-true", "predicate", "with", "the", "same", "mode", "as", "TARGET", "." ]

[ "aarch64" ]

[]

[ "<s>", "int", "getNext", "(", ")", "{", "return", "last", "=", "Clusters", ".", "pop_back_val", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "next", "SDUse", "in", "the", "use", "list", "." ]

[ "TMS320C64X" ]

[]

[ "<s>", "static", "bool", "fr30_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "fr30" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "M", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.amdgcn.dispatch.id\"", ",", "\"amdgpu-dispatch-id\"", "}", ",", "{", "\"llvm.trap\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.debugtrap\"", ",", "\"amdgpu-queue-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "Mesa3D", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "bool", "HasApertureRegs", "=", "TM", "&&", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ".", "hasApertureRegs", "(", ")", ";", "if", "(", "!", "HasApertureRegs", "&&", "hasAddrSpaceCast", "(", "F", ",", "AS", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::getAMDGPUAS", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"llvm.amdgcn.dispatch.id\"", "\"amdgpu-dispatch-id\"", "\"llvm.trap\"", "\"amdgpu-queue-ptr\"", "\"llvm.debugtrap\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"", "AMDGPU", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "static", "bool", "pa_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_64BIT", ")", "return", "false", ";", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "return", "false", ";", "return", "decl", "&&", "targetm", ".", "binds_local_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Only", "direct", "calls", "to", "static", "functions", "are", "allowed", "to", "be", "sibling", "(", "tail", ")", "call", "optimized", ".", "This", "restriction", "is", "necessary", "because", "some", "linker", "generated", "stubs", "will", "store", "return", "pointers", "into", "rp", "'", "in", "some", "cases", "which", "might", "clobber", "a", "live", "value", "already", "in", "rp", "'", ".", "In", "a", "sibcall", "the", "current", "function", "and", "the", "target", "function", "share", "stack", "space", ".", "Thus", "if", "the", "path", "to", "the", "current", "function", "and", "the", "path", "to", "the", "target", "function", "save", "a", "value", "in", "rp", "'", ",", "they", "save", "the", "value", "into", "the", "same", "stack", "slot", ",", "which", "has", "undesirable", "consequences", ".", "Because", "of", "the", "deferred", "binding", "nature", "of", "shared", "libraries", "any", "function", "with", "external", "scope", "could", "be", "in", "a", "different", "load", "module", "and", "thus", "require", "rp", "'", "to", "be", "saved", "when", "calling", "that", "function", ".", "So", "sibcall", "optimizations", "can", "only", "be", "safe", "for", "static", "function", ".", "Note", "that", "GCC", "never", "needs", "return", "value", "relocations", ",", "so", "we", "do", "n't", "have", "to", "worry", "about", "static", "calls", "with", "return", "value", "relocations", "(", "which", "require", "saving", "rp", "'", ")", ".", "It", "is", "safe", "to", "perform", "a", "sibcall", "optimization", "when", "the", "target", "function", "will", "never", "return", "." ]

[ "pa" ]

[]

[ "<s>", "static", "void", "arc_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "int", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ":", "NULL_TREE", ")", ";", "tree", "long_call_attr", "=", "lookup_attribute", "(", "\"long_call\"", ",", "attr", ")", ";", "tree", "medium_call_attr", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "attr", ")", ";", "tree", "short_call_attr", "=", "lookup_attribute", "(", "\"short_call\"", ",", "attr", ")", ";", "if", "(", "long_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_LONG_CALL", ";", "else", "if", "(", "medium_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_MEDIUM_CALL", ";", "else", "if", "(", "short_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_SHORT_CALL", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "=", "flags", ";", "}", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "DECL_ATTRIBUTES", "(", "decl", ")", ":", "NULL_TREE", ")", ";", "tree", "sec_attr", "=", "lookup_attribute", "(", "\"section\"", ",", "attr", ")", ";", "if", "(", "sec_attr", ")", "{", "const", "char", "*", "sec_name", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "sec_attr", ")", ")", ")", ";", "if", "(", "strcmp", "(", "sec_name", ",", "\".cmem\"", ")", "==", "0", "||", "strcmp", "(", "sec_name", ",", "\".cmem_shared\"", ")", "==", "0", "||", "strcmp", "(", "sec_name", ",", "\".cmem_private\"", ")", "==", "0", ")", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "|=", "SYMBOL_FLAG_CMEM", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_ENCODE_SECTION_INFO", "hook", "." ]

[ "arc", "0", "\"long_call\"", "\"medium_call\"", "\"short_call\"", "0", "\"section\"", "\".cmem\"", "0", "\".cmem_shared\"", "0", "\".cmem_private\"", "0" ]

[]

[ "<s>", "static", "bool", "msp430_use_16bit_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "if", "(", "msp430_hwmult_type", "==", "MSP430_HWMULT_SMALL", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "MSP430_HWMULT_AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "msp430_extract_mcu_data", "(", "target_mcu", ")", ";", "if", "(", "extracted_mcu_data", ".", "name", "!=", "NULL", ")", "return", "cached_result", "=", "(", "extracted_mcu_data", ".", "hwmpy", "==", "1", "||", "extracted_mcu_data", ".", "hwmpy", "==", "2", ")", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "has", "a", "first", "generation", "16-bit", "hardware", "multiplier", "." ]

[ "msp430", "1", "2" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", ".", "isDarwin", "(", ")", ")", "RegName", "=", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "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", "\"r0\"", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ".", "resolve", "(", ")", ")", ";", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "auto", "FuncTypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getSectionName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "static", "rtx", "sparc_delegitimize_address", "(", "rtx", "x", ")", "{", "x", "=", "delegitimize_mem_from_attrs", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_MOVE_PIC", ":", "case", "UNSPEC_TLSLE", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "break", ";", "case", "UNSPEC_MOVE_GOTDATA", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "2", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", "&&", "(", "XEXP", "(", "x", ",", "0", ")", "==", "got_register_rtx", "||", "sparc_pic_register_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "rtx", "y", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "LO_SUM", ")", "y", "=", "XEXP", "(", "y", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", "&&", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_MOVE_PIC_LABEL", ")", "{", "x", "=", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Delegitimize", "an", "address", "that", "was", "legitimized", "by", "the", "above", "function", "." ]

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

[]

[ "<s>", "static", "int", "min_insn_size", "(", "rtx", "insn", ")", "{", "int", "l", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "!", "active_insn_p", "(", "insn", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", "&&", "!", "SIBLING_CALL_P", "(", "insn", ")", ")", "return", "5", ";", "if", "(", "get_attr_length", "(", "insn", ")", "<=", "1", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "JUMP_INSN", ")", "{", "l", "=", "get_attr_length_address", "(", "insn", ")", ";", "if", "(", "l", "<", "4", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "l", "=", "4", ";", "}", "if", "(", "l", ")", "return", "1", "+", "l", ";", "else", "return", "2", ";", "}", "</s>" ]

[ "We", "do", "n't", "have", "exact", "information", "about", "the", "insn", "sizes", ",", "but", "we", "may", "assume", "quite", "safely", "that", "we", "are", "informed", "about", "all", "1", "byte", "insns", "and", "memory", "address", "sizes", ".", "This", "is", "enough", "to", "eliminate", "unnecessary", "padding", "in", "99", "%", "of", "cases", "." ]

[ "i386", "0", "0", "1", "0", "0", "5", "1", "1", "4", "4", "1", "2" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "AArch64", "::", "GPR32commonRegClass", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "i", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "GPR32commonRegClass", ".", "getRegister", "(", "i", ")", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::WSP", "AArch64::WZR", "AArch64::W29", "0", "AArch64::GPR32commonRegClass", "AArch64", "AArch64::GPR32commonRegClass", "AArch64::W19" ]

[]

[ "<s>", "EVT", "RISCVTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "RISCV", "RISCV", "MVT::getVectorVT", "MVT::i1" ]

[]

[ "<s>", "bool", "ARMConstantIslands", "::", "isBBInRange", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "DestBB", ",", "unsigned", "MaxDisp", ")", "{", "unsigned", "PCAdj", "=", "isThumb", "?", "4", ":", "8", ";", "unsigned", "BrOffset", "=", "getOffsetOf", "(", "MI", ")", "+", "PCAdj", ";", "unsigned", "DestOffset", "=", "BBInfo", "[", "DestBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Branch of destination \"", "<<", "printMBBReference", "(", "*", "DestBB", ")", "<<", "\" from \"", "<<", "printMBBReference", "(", "*", "MI", "->", "getParent", "(", ")", ")", "<<", "\" max delta=\"", "<<", "MaxDisp", "<<", "\" from \"", "<<", "getOffsetOf", "(", "MI", ")", "<<", "\" to \"", "<<", "DestOffset", "<<", "\" offset \"", "<<", "int", "(", "DestOffset", "-", "BrOffset", ")", "<<", "\"\\t\"", "<<", "*", "MI", ")", ";", "if", "(", "BrOffset", "<=", "DestOffset", ")", "{", "if", "(", "DestOffset", "-", "BrOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "else", "{", "if", "(", "BrOffset", "-", "DestOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isBBInRange", "-", "Returns", "true", "if", "the", "distance", "between", "specific", "MI", "and", "specific", "BB", "can", "fit", "in", "MI", "'s", "displacement", "field", "." ]

[ "ARM", "ARM", "4", "8", "\"Branch of destination \"", "\" from \"", "\" max delta=\"", "\" from \"", "\" to \"", "\" offset \"", "\"\\t\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", ".", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", "||", "CopyVT", "==", "MVT", "::", "f128", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", ".", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "bool", "RoundAfterCopy", "=", "false", ";", "if", "(", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "&&", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "hasX87", "(", ")", ")", "report_fatal_error", "(", "\"X87 register return with X87 disabled\"", ")", ";", "CopyVT", "=", "MVT", "::", "f80", ";", "RoundAfterCopy", "=", "(", "CopyVT", "!=", "VA", ".", "getLocVT", "(", ")", ")", ";", "}", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "RoundAfterCopy", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ",", "dl", ")", ")", ";", "if", "(", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "MVT::f128", "\"SSE register return with SSE disabled\"", "X86::FP0", "X86::FP1", "\"X87 register return with X87 disabled\"", "MVT::f80", "1", "0", "ISD::FP_ROUND", "1", "MVT::i1", "ISD::TRUNCATE", "2" ]

[]

[ "<s>", "void", "SystemZRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "StackSize", "-=", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mr", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mrm", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "-", "(", "int64_t", ")", "NumBytes", ",", "TII", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "SystemZ", "::", "MOV64rr", ")", ",", "SystemZ", "::", "R11D", ")", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "SystemZ", "::", "R11D", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "SystemZ::MOV64rr", "SystemZ::R11D", "SystemZ::R15D", "SystemZ::R11D" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "checkMAIHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "MI", "->", "mayLoad", "(", ")", "||", "MI", "->", "mayStore", "(", ")", ")", "&&", "checkMAILdStHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkAnyInstHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "static", "enum", "mips_symbol_type", "mips_classify_symbol", "(", "const_rtx", "x", ",", "enum", "mips_symbol_context", "context", ")", "{", "if", "(", "TARGET_RTP_PIC", ")", "return", "SYMBOL_GOT_DISP", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "if", "(", "TARGET_MIPS16_SHORT_JUMP_TABLES", "&&", "!", "LABEL_REF_NONLOCAL_P", "(", "x", ")", ")", "return", "SYMBOL_PC_RELATIVE", ";", "if", "(", "TARGET_ABICALLS", "&&", "!", "TARGET_ABSOLUTE_ABICALLS", ")", "return", "SYMBOL_GOT_PAGE_OFST", ";", "return", "SYMBOL_ABSOLUTE", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "SYMBOL_TLS", ";", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "TARGET_MIPS16_TEXT_LOADS", ")", "return", "SYMBOL_PC_RELATIVE", ";", "if", "(", "TARGET_MIPS16_PCREL_LOADS", "&&", "context", "==", "SYMBOL_CONTEXT_MEM", ")", "return", "SYMBOL_PC_RELATIVE", ";", "if", "(", "mips_rtx_constant_in_small_data_p", "(", "get_pool_mode", "(", "x", ")", ")", ")", "return", "SYMBOL_GP_RELATIVE", ";", "}", "if", "(", "TARGET_GPOPT", "&&", "SYMBOL_REF_SMALL_P", "(", "x", ")", "&&", "!", "SYMBOL_REF_WEAK", "(", "x", ")", ")", "return", "SYMBOL_GP_RELATIVE", ";", "if", "(", "TARGET_ABICALLS_PIC2", "&&", "!", "(", "TARGET_ABSOLUTE_ABICALLS", "&&", "mips_symbol_binds_local_p", "(", "x", ")", ")", ")", "{", "if", "(", "mips_global_symbol_p", "(", "x", ")", ")", "return", "SYMBOL_GOT_DISP", ";", "return", "SYMBOL_GOT_PAGE_OFST", ";", "}", "return", "SYMBOL_ABSOLUTE", ";", "}", "</s>" ]

[ "Classify", "symbol", "X", ",", "which", "must", "be", "a", "SYMBOL_REF", "or", "a", "LABEL_REF", "." ]

[ "mips" ]

[]

[ "<s>", "static", "int", "c4x_r11_set_p", "(", "rtx", "x", ")", "{", "rtx", "set", ";", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "x", "==", "0", ")", "return", "0", ";", "if", "(", "INSN_P", "(", "x", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "x", ")", ")", "==", "SEQUENCE", ")", "x", "=", "XVECEXP", "(", "PATTERN", "(", "x", ")", ",", "0", ",", "XVECLEN", "(", "PATTERN", "(", "x", ")", ",", "0", ")", "-", "1", ")", ";", "if", "(", "INSN_P", "(", "x", ")", "&&", "(", "set", "=", "single_set", "(", "x", ")", ")", ")", "x", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", "==", "R11_REGNO", ")", "return", "1", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "c4x_r11_set_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "c4x_r11_set_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Check", "if", "register", "r11", "is", "used", "as", "the", "destination", "of", "an", "insn", "." ]

[ "c4x", "0", "0", "0", "0", "1", "1", "1", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "ix86_expand_binary_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "src1", ",", "src2", ",", "dst", ",", "op", ",", "clob", ";", "dst", "=", "ix86_fixup_binary_operands", "(", "code", ",", "mode", ",", "operands", ")", ";", "src1", "=", "operands", "[", "1", "]", ";", "src2", "=", "operands", "[", "2", "]", ";", "op", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "src1", ",", "src2", ")", ")", ";", "if", "(", "reload_completed", "&&", "code", "==", "PLUS", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "{", "emit_insn", "(", "op", ")", ";", "}", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "expand", "a", "binary", "operator", ".", "Make", "the", "expansion", "closer", "to", "the", "actual", "machine", ",", "then", "just", "general_operand", ",", "which", "will", "allow", "3", "separate", "memory", "references", "(", "one", "output", ",", "two", "input", ")", "in", "a", "single", "insn", "." ]

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

[]

[ "<s>", "static", "int", "avr_naked_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"naked\"", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "FUNC", "is", "a", "naked", "function", "." ]

[ "avr", "\"naked\"" ]

[]

[ "<s>", "bool", "SparcTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createSparcISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "static", "rtx", "aarch64_simd_make_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "const_dup", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_const", "=", "0", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "int", "n_elts", "=", "XVECLEN", "(", "vals", ",", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL_RTX", "&&", "aarch64_simd_valid_immediate", "(", "const_vec", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "(", "const_dup", "=", "aarch64_simd_dup_constant", "(", "vals", ")", ")", "!=", "NULL_RTX", ")", "return", "const_dup", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]

[ "aarch64", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM64 Conditional Compares\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Conditional Compares\"" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "LHSTy", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "AVR", "MVT::i8" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "if", "(", "processInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "Out", ".", "EmitInstruction", "(", "Instructions", "[", "i", "]", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Mips", "Mips", "8", "0", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "Mips", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "static", "void", "pop", "(", "int", "rn", ")", "{", "rtx", "x", ",", "sp_reg", ",", "reg", ";", "if", "(", "rn", "==", "FPUL_REG", ")", "x", "=", "gen_pop_fpul", "(", ")", ";", "else", "if", "(", "rn", "==", "FPSCR_REG", ")", "x", "=", "gen_pop_fpscr", "(", ")", ";", "else", "if", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "TARGET_FMOVD", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_OR_XD_REGISTER_P", "(", "rn", ")", ")", "{", "if", "(", "FP_REGISTER_P", "(", "rn", ")", "&&", "(", "rn", "-", "FIRST_FP_REG", ")", "&", "1", ")", "return", ";", "x", "=", "gen_pop_4", "(", "gen_rtx_REG", "(", "DFmode", ",", "rn", ")", ")", ";", "}", "else", "if", "(", "TARGET_SH2E", "&&", "FP_REGISTER_P", "(", "rn", ")", ")", "x", "=", "gen_pop_e", "(", "gen_rtx_REG", "(", "SFmode", ",", "rn", ")", ")", ";", "else", "x", "=", "gen_pop", "(", "gen_rtx_REG", "(", "SImode", ",", "rn", ")", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "reg", "=", "copy_rtx", "(", "GET_CODE", "(", "PATTERN", "(", "x", ")", ")", "==", "PARALLEL", "?", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "x", ")", ",", "0", ",", "0", ")", ")", ":", "SET_DEST", "(", "PATTERN", "(", "x", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "sp_reg", ",", "plus_constant", "(", "SImode", ",", "sp_reg", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

[ "sh", "1", "0", "0", "1" ]

[]

[ "<s>", "MachineInstr", "*", "AArch64InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "SrcReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DstReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "if", "(", "DstReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "AArch64", "AArch64", "0", "1", "AArch64::SP", "AArch64::GPR64RegClass", "AArch64::SP", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "bool", "CSKYAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "CSKYOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "CSKY", "CSKY", "CSKYOperand::createToken", "\"unexpected token\"" ]

[]

[ "<s>", "static", "void", "expand_setmem_epilogue_via_loop", "(", "rtx", "destmem", ",", "rtx", "destptr", ",", "rtx", "value", ",", "rtx", "count", ",", "int", "max_size", ")", "{", "count", "=", "expand_simple_binop", "(", "counter_mode", "(", "count", ")", ",", "AND", ",", "count", ",", "GEN_INT", "(", "max_size", "-", "1", ")", ",", "count", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "expand_set_or_cpymem_via_loop", "(", "destmem", ",", "NULL", ",", "destptr", ",", "NULL", ",", "gen_lowpart", "(", "QImode", ",", "value", ")", ",", "count", ",", "QImode", ",", "1", ",", "max_size", "/", "2", ",", "true", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "set", "at", "most", "count", "&", "(", "max_size", "-", "1", ")", "bytes", "starting", "by", "DEST", "." ]

[ "i386", "1", "1", "1", "2" ]

[]

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

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

[ "CSKY" ]

[]

[ "<s>", "bool", "M68kInstructionLookupBuilder", "::", "isValid", "(", ")", "const", "{", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "numWords", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "if", "(", "Mask", "[", "I", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "M68k", "M68k", "0" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isA9", "=", "STI", "->", "isCortexA9", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitLoadLinked", "(", "IRBuilderBase", "&", "Builder", ",", "Type", "*", "ValueTy", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "SZ", "=", "ValueTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic loads supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_L2_loadw_locked", ":", "Intrinsic", "::", "hexagon_L4_loadd_locked", ";", "Function", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "auto", "PtrTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", ";", "PointerType", "*", "NewPtrTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", "->", "getPointerTo", "(", "PtrTy", "->", "getAddressSpace", "(", ")", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "NewPtrTy", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "Addr", ",", "\"larx\"", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Call", ",", "ValueTy", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic loads supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_L2_loadw_locked", "Intrinsic::hexagon_L4_loadd_locked", "Intrinsic::getDeclaration", "\"larx\"" ]

[]

[ "<s>", "static", "void", "arm_elf_asm_constructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "arm_elf_asm_cdtor", "(", "symbol", ",", "priority", ",", "true", ")", ";", "}", "</s>" ]

[ "Add", "a", "function", "to", "the", "list", "of", "static", "constructors", "." ]

[ "arm" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Packetizer\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Packetizer\"" ]

[]

[ "<s>", "static", "int", "rs6000_issue_rate", "(", ")", "{", "switch", "(", "rs6000_cpu_attr", ")", "{", "case", "CPU_RIOS1", ":", "case", "CPU_RS64A", ":", "case", "CPU_PPC601", ":", "case", "CPU_PPC7450", ":", "return", "3", ";", "case", "CPU_PPC603", ":", "case", "CPU_PPC750", ":", "case", "CPU_PPC7400", ":", "return", "2", ";", "case", "CPU_RIOS2", ":", "case", "CPU_PPC604", ":", "case", "CPU_PPC604E", ":", "case", "CPU_PPC620", ":", "case", "CPU_PPC630", ":", "return", "4", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "the", "machine", "can", "issue", "per", "cycle", "." ]

[ "rs6000", "3", "2", "4", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "loongarch_restore_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "insn", "=", "loongarch_emit_move", "(", "reg", ",", "mem", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Restore", "register", "REG", "from", "MEM", "." ]

[ "loongarch", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasVFP3", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "return", "ARM_AM", "::", "getFP16Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "ARM_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "Subtarget", "->", "isFPOnlySP", "(", ")", ")", "return", "ARM_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "MVT::f16", "ARM_AM::getFP16Imm", "1", "MVT::f32", "ARM_AM::getFP32Imm", "1", "MVT::f64", "ARM_AM::getFP64Imm", "1" ]

[]

[ "<s>", "static", "bool", "ix86_optab_supported_p", "(", "int", "op", ",", "machine_mode", "mode1", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "asin_optab", ":", "case", "acos_optab", ":", "case", "log1p_optab", ":", "case", "exp_optab", ":", "case", "exp10_optab", ":", "case", "exp2_optab", ":", "case", "expm1_optab", ":", "case", "ldexp_optab", ":", "case", "scalb_optab", ":", "case", "round_optab", ":", "case", "lround_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rint_optab", ":", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "!", "flag_trapping_math", "&&", "!", "TARGET_SSE4_1", "&&", "mode1", "!=", "HFmode", ")", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "return", "true", ";", "case", "floor_optab", ":", "case", "ceil_optab", ":", "case", "btrunc_optab", ":", "if", "(", "(", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "TARGET_SSE4_1", ")", "||", "mode1", "==", "HFmode", ")", "&&", "!", "flag_trapping_math", ")", "return", "true", ";", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rsqrt_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "use_rsqrt_p", "(", "mode1", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "i386" ]

[]

[ "<s>", "void", "AVRRegisterInfo", "::", "splitReg", "(", "Register", "Reg", ",", "Register", "&", "LoReg", ",", "Register", "&", "HiReg", ")", "const", "{", "assert", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "AVR", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "AVR", "::", "sub_hi", ")", ";", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "AVR", "AVR", "AVR::DREGSRegClass", "\"can only split 16-bit registers\"", "AVR::sub_lo", "AVR::sub_hi" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "emitFunctionStart", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "printInstruction", "(", "II", ")", ";", "++", "EmittedInsts", ";", "}", "O", "<<", "'\\n'", ";", "}", "emitFunctionEnd", "(", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"\\n\\n\"" ]

[]

[ "<s>", "int", "m32c_epilogue_uses", "(", "int", "regno", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "EPILOGUE_USES", ".", "Interrupts", "restore", "all", "registers", "." ]

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

[]

[ "<s>", "static", "unsigned", "getIntrinsicID", "(", "const", "SDNode", "*", "N", ")", "{", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "Intrinsic", "::", "not_intrinsic", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IID", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "IID", "<", "Intrinsic", "::", "num_intrinsics", ")", "return", "IID", ";", "return", "Intrinsic", "::", "not_intrinsic", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "target", "intrinsic", "ID", "of", "a", "function", ",", "or", "0", "." ]

[ "AArch64", "Intrinsic::not_intrinsic", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::num_intrinsics", "Intrinsic::not_intrinsic" ]

[]

[ "<s>", "gimple", "*", "fold", "(", "gimple_folder", "&", "f", ")", "const", "override", "{", "auto_vec", "<", "tree", ">", "vargs", "(", "gimple_call_num_args", "(", "f", ".", "call", ")", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "gimple_call_num_args", "(", "f", ".", "call", ")", ";", "i", "++", ")", "{", "if", "(", "i", "==", "gimple_call_num_args", "(", "f", ".", "call", ")", "-", "2", ")", "continue", ";", "vargs", ".", "quick_push", "(", "gimple_call_arg", "(", "f", ".", "call", ",", "i", ")", ")", ";", "}", "gimple", "*", "repl", "=", "gimple_build_call_vec", "(", "gimple_call_fn", "(", "f", ".", "call", ")", ",", "vargs", ")", ";", "gimple_call_set_lhs", "(", "repl", ",", "f", ".", "lhs", ")", ";", "tree", "new_vl", "=", "gimple_call_arg", "(", "f", ".", "call", ",", "gimple_call_num_args", "(", "f", ".", "call", ")", "-", "2", ")", ";", "if", "(", "integer_zerop", "(", "new_vl", ")", ")", "{", "return", "repl", ";", "}", "tree", "tmp_var", "=", "create_tmp_var", "(", "size_type_node", ",", "\"new_vl\"", ")", ";", "tree", "decl", "=", "get_read_vl_decl", "(", ")", ";", "gimple", "*", "g", "=", "gimple_build_call", "(", "decl", ",", "0", ")", ";", "gimple_call_set_lhs", "(", "g", ",", "tmp_var", ")", ";", "tree", "indirect", "=", "fold_build2", "(", "MEM_REF", ",", "size_type_node", ",", "gimple_call_arg", "(", "f", ".", "call", ",", "gimple_call_num_args", "(", "f", ".", "call", ")", "-", "2", ")", ",", "build_int_cst", "(", "build_pointer_type", "(", "size_type_node", ")", ",", "0", ")", ")", ";", "gassign", "*", "assign", "=", "gimple_build_assign", "(", "indirect", ",", "tmp_var", ")", ";", "gsi_insert_after", "(", "f", ".", "gsi", ",", "assign", ",", "GSI_SAME_STMT", ")", ";", "gsi_insert_after", "(", "f", ".", "gsi", ",", "g", ",", "GSI_SAME_STMT", ")", ";", "return", "repl", ";", "}", "</s>" ]

[ "Try", "to", "fold", "the", "call", ".", "Return", "the", "new", "statement", "on", "success", "and", "null", "on", "failure", "." ]

[ "riscv", "1", "0", "2", "2", "\"new_vl\"", "0", "2", "0" ]

[]

[ "<s>", "bool", "rs6000_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ",", "*", "cur_opt", ";", "HOST_WIDE_INT", "prev_flags", ",", "cur_flags", ",", "diff_flags", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_pragma_target_parse\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"args:\"", ")", ";", "rs6000_debug_target_options", "(", "args", ",", "\" \"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "pop_target", ")", "{", "fprintf", "(", "stderr", ",", "\"pop_target:\\n\"", ")", ";", "debug_tree", "(", "pop_target", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "\"pop_target: <NULL>\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "1", ";", "if", "(", "!", "rs6000_inner_target_options", "(", "args", ",", "false", ")", "||", "!", "rs6000_option_override_internal", "(", "false", ")", "||", "(", "cur_tree", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ")", "==", "NULL_TREE", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"invalid pragma\\n\"", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "rs6000_activate_target_options", "(", "target_option_current_node", ")", ";", "if", "(", "rs6000_target_modify_macros_ptr", ")", "{", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "prev_flags", "=", "prev_opt", "->", "x_rs6000_isa_flags", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "cur_flags", "=", "cur_opt", "->", "x_rs6000_isa_flags", ";", "diff_flags", "=", "(", "prev_flags", "^", "cur_flags", ")", ";", "if", "(", "diff_flags", "!=", "0", ")", "{", "rs6000_target_modify_macros_ptr", "(", "false", ",", "prev_flags", "&", "diff_flags", ")", ";", "rs6000_target_modify_macros_ptr", "(", "true", ",", "cur_flags", "&", "diff_flags", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "rs6000", "\"\\n==================== rs6000_pragma_target_parse\\n\"", "\"args:\"", "\" \"", "\"\\n\"", "\"pop_target:\\n\"", "\"pop_target: <NULL>\\n\"", "\"--------------------\\n\"", "1", "\"invalid pragma\\n\"", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "if", "(", "NumBits1", "<=", "NumBits2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "X86", "X86" ]

[]