Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "!", "validateInstruction", "(", "Inst", ",", "IDLoc", ")", ")", "{", "return", "true", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "\"unrecognized instruction mnemonic\"", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "TriCoreFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineFunction", "::", "iterator", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "MOV_AAsrr", ")", ",", "TriCore", "::", "A14", ")", ".", "addReg", "(", "TriCore", "::", "A10", ")", ";", "for", "(", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "TriCore", "::", "A14", ")", ";", "}", "unsigned", "StackReg", "=", "TriCore", "::", "A10", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "SUB_Arr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "SUB_Asc", ")", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "TriCore", "TriCore", "TriCore::MOV_AAsrr", "TriCore::A14", "TriCore::A10", "TriCore::A14", "TriCore::A10", "TriCore::SUB_Arr", "TriCore::SUB_Asc" ]

[]

[ "<s>", "bool", "s390_legitimate_address_without_index_p", "(", "rtx", "op", ")", "{", "struct", "s390_address", "addr", ";", "if", "(", "!", "s390_decompose_address", "(", "XEXP", "(", "op", ",", "0", ")", ",", "&", "addr", ")", ")", "return", "false", ";", "if", "(", "addr", ".", "indx", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "CODE", "is", "a", "valid", "address", "without", "index", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "bool", "ix86_libgcc_floating_mode_supported_p", "(", "scalar_float_mode", "mode", ")", "{", "return", "(", "(", "mode", "==", "HFmode", "&&", "TARGET_SSE2", ")", "?", "true", ":", "default_libgcc_floating_mode_supported_p", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "libgcc_floating_mode_supported_p", "." ]

[ "i386" ]

[]

[ "<s>", "void", "expand_prologue", "(", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ";", "size", "+=", "(", "current_function_outgoing_args_size", "?", "4", ":", "0", ")", ";", "if", "(", "current_function_varargs", ")", "{", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "4", ")", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "8", ")", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ")", ";", "}", "mn10300_gen_multiple_store", "(", "mn10300_get_live_callee_saved_regs", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "if", "(", "size", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "prologue", "into", "RTL", "." ]

[ "mn10300", "4", "0", "4", "0", "8", "1" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "GlobalBaseReg", "=", "0", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "if", "(", "!", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", ")", "InsertVRSaveCode", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "match_addli_pcrel", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "unspec", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "LO_SUM", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "1", ")", ")", "!=", "CONST", ")", "return", "false", ";", "unspec", "=", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "1", ")", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", "&&", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_PCREL_SYM", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "INSN", "is", "a", "pc-relative", "addli", "insn", "." ]

[ "tilepro", "1", "1", "0", "1" ]

[]

[ "<s>", "void", "PatmosPostRASchedStrategy", "::", "registerRoots", "(", ")", "{", "ReadyQ", ".", "initialize", "(", ")", ";", "}", "</s>" ]

[ "Notify", "this", "strategy", "that", "all", "roots", "have", "been", "released", "(", "including", "those", "that", "depend", "on", "EntrySU", "or", "ExitSU", ")", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isTargetLinux", "(", ")", ")", "return", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "Function", "*", "AArch64TargetLowering", "::", "getSSPStackGuardCheck", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", ")", "return", "M", ".", "getFunction", "(", "\"__security_check_cookie\"", ")", ";", "return", "TargetLowering", "::", "getSSPStackGuardCheck", "(", "M", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "stack", "protection", "check", "function", "that", "performs", "validation", "and", "error", "handling", ",", "returns", "the", "function", "." ]

[ "AArch64", "AArch64", "\"__security_check_cookie\"" ]

[]

[ "<s>", "X86ProcFamilyEnum", "getProcFamily", "(", ")", "const", "{", "return", "X86ProcFamily", ";", "}", "</s>" ]

[ "Returns", "RISC-V", "processor", "family", "." ]

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

[]

[ "<s>", "static", "enum", "arm_cond_code", "get_arm_condition_code", "(", "rtx", "comparison", ")", "{", "enum", "arm_cond_code", "code", "=", "maybe_get_arm_condition_code", "(", "comparison", ")", ";", "gcc_assert", "(", "code", "!=", "ARM_NV", ")", ";", "return", "code", ";", "}", "</s>" ]

[ "Returns", "the", "index", "of", "the", "ARM", "condition", "code", "string", "in", "`", "arm_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "vax_lra_p", "(", "void", ")", "{", "return", "TARGET_LRA", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "vax" ]

[]

[ "<s>", "static", "tree", "aarch64_simd_builtin_type", "(", "enum", "machine_mode", "mode", ",", "bool", "unsigned_p", ",", "bool", "poly_p", ")", "{", "if", "(", "poly_p", ")", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_poly", ")", ";", "else", "if", "(", "unsigned_p", ")", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_unsigned", ")", ";", "else", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_none", ")", ";", "}", "</s>" ]

[ "Return", "a", "type", "for", "an", "operand", "with", "specified", "mode", "and", "qualifiers", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "mips_frame_set", "(", "rtx", "mem", ",", "rtx", "reg", ")", "{", "rtx", "set", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "GP_REG_FIRST", "+", "31", "&&", "DWARF_FRAME_RETURN_COLUMN", "!=", "GP_REG_FIRST", "+", "31", ")", "reg", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "reg", ")", ",", "DWARF_FRAME_RETURN_COLUMN", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "a", "frame-related", "rtx", "that", "stores", "register", "REGNO", "at", "(", "SP", "+", "OFFSET", ")", ".", "The", "expression", "should", "only", "be", "used", "to", "store", "single", "registers", "." ]

[ "mips", "31", "31", "1" ]

[]

[ "<s>", "static", "rtx", "ia64_unpack_sign", "(", "rtx", "vec", ",", "bool", "unsignedp", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vec", ")", ";", "rtx", "zero", "=", "CONST0_RTX", "(", "mode", ")", ";", "if", "(", "unsignedp", ")", "return", "zero", ";", "else", "{", "rtx", "sign", "=", "gen_reg_rtx", "(", "mode", ")", ";", "bool", "neg", ";", "neg", "=", "ia64_expand_vecint_compare", "(", "LT", ",", "mode", ",", "sign", ",", "vec", ",", "zero", ")", ";", "gcc_assert", "(", "!", "neg", ")", ";", "return", "sign", ";", "}", "}", "</s>" ]

[ "Return", "a", "vector", "of", "the", "sign-extension", "of", "VEC", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "void", "aarch64_update_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "aarch64_def_or_undef", "(", "flag_unsafe_math_optimizations", ",", "\"__ARM_FP_FAST\"", ",", "pfile", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ARCH\"", ",", "aarch64_architecture_version", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_SIZEOF_MINIMAL_ENUM\"", ",", "flag_short_enums", "?", "1", ":", "4", ")", ";", "aarch64_def_or_undef", "(", "TARGET_BIG_END", ",", "\"__AARCH64EB__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_BIG_END", ",", "\"__ARM_BIG_ENDIAN\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "!", "TARGET_BIG_END", ",", "\"__AARCH64EL__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_FLOAT", ",", "\"__ARM_FEATURE_FMA\"", ",", "pfile", ")", ";", "if", "(", "TARGET_FLOAT", "||", "TARGET_SIMD", ")", "{", "builtin_define_with_int_value", "(", "\"__ARM_FP\"", ",", "0x0E", ")", ";", "builtin_define", "(", "\"__ARM_FP16_FORMAT_IEEE\"", ")", ";", "builtin_define", "(", "\"__ARM_FP16_ARGS\"", ")", ";", "}", "else", "cpp_undef", "(", "pfile", ",", "\"__ARM_FP\"", ")", ";", "aarch64_def_or_undef", "(", "TARGET_FP_F16INST", ",", "\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD_F16INST", ",", "\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD", ",", "\"__ARM_FEATURE_NUMERIC_MAXMIN\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD", ",", "\"__ARM_NEON\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_CRC32", ",", "\"__ARM_FEATURE_CRC32\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_DOTPROD", ",", "\"__ARM_FEATURE_DOTPROD\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_TINY__\"", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_SMALL__\"", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__AARCH64_CMODEL_LARGE__\"", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "case", "AARCH64_CMODEL_TINY_PIC", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_TINY__\"", ")", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_SMALL__\"", ")", ";", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "builtin_define", "(", "\"__AARCH64_CMODEL_LARGE__\"", ")", ";", "break", ";", "default", ":", "break", ";", "}", "aarch64_def_or_undef", "(", "TARGET_ILP32", ",", "\"_ILP32\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_ILP32", ",", "\"__ILP32__\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_CRYPTO", ",", "\"__ARM_FEATURE_CRYPTO\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SIMD_RDMA", ",", "\"__ARM_FEATURE_QRDMX\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SVE", ",", "\"__ARM_FEATURE_SVE\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__ARM_FEATURE_SVE_BITS\"", ")", ";", "if", "(", "TARGET_SVE", ")", "{", "int", "bits", ";", "if", "(", "!", "BITS_PER_SVE_VECTOR", ".", "is_constant", "(", "&", "bits", ")", ")", "bits", "=", "0", ";", "builtin_define_with_int_value", "(", "\"__ARM_FEATURE_SVE_BITS\"", ",", "bits", ")", ";", "}", "aarch64_def_or_undef", "(", "TARGET_AES", ",", "\"__ARM_FEATURE_AES\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA2", ",", "\"__ARM_FEATURE_SHA2\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA3", ",", "\"__ARM_FEATURE_SHA3\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SHA3", ",", "\"__ARM_FEATURE_SHA512\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SM4", ",", "\"__ARM_FEATURE_SM3\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_SM4", ",", "\"__ARM_FEATURE_SM4\"", ",", "pfile", ")", ";", "aarch64_def_or_undef", "(", "TARGET_F16FML", ",", "\"__ARM_FEATURE_FP16_FML\"", ",", "pfile", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__FLT_EVAL_METHOD__\"", ")", ";", "builtin_define_with_int_value", "(", "\"__FLT_EVAL_METHOD__\"", ",", "c_flt_eval_method", "(", "true", ")", ")", ";", "cpp_undef", "(", "pfile", ",", "\"__FLT_EVAL_METHOD_C99__\"", ")", ";", "builtin_define_with_int_value", "(", "\"__FLT_EVAL_METHOD_C99__\"", ",", "c_flt_eval_method", "(", "false", ")", ")", ";", "}", "</s>" ]

[ "Undefine/redefine", "macros", "that", "depend", "on", "the", "current", "backend", "state", "and", "may", "need", "to", "change", "when", "a", "target", "pragma", "modifies", "the", "backend", "state", "." ]

[ "aarch64", "\"__ARM_FP_FAST\"", "\"__ARM_ARCH\"", "\"__ARM_SIZEOF_MINIMAL_ENUM\"", "1", "4", "\"__AARCH64EB__\"", "\"__ARM_BIG_ENDIAN\"", "\"__AARCH64EL__\"", "\"__ARM_FEATURE_FMA\"", "\"__ARM_FP\"", "0x0E", "\"__ARM_FP16_FORMAT_IEEE\"", "\"__ARM_FP16_ARGS\"", "\"__ARM_FP\"", "\"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC\"", "\"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC\"", "\"__ARM_FEATURE_NUMERIC_MAXMIN\"", "\"__ARM_NEON\"", "\"__ARM_FEATURE_CRC32\"", "\"__ARM_FEATURE_DOTPROD\"", "\"__AARCH64_CMODEL_TINY__\"", "\"__AARCH64_CMODEL_SMALL__\"", "\"__AARCH64_CMODEL_LARGE__\"", "\"__AARCH64_CMODEL_TINY__\"", "\"__AARCH64_CMODEL_SMALL__\"", "\"__AARCH64_CMODEL_LARGE__\"", "\"_ILP32\"", "\"__ILP32__\"", "\"__ARM_FEATURE_CRYPTO\"", "\"__ARM_FEATURE_QRDMX\"", "\"__ARM_FEATURE_SVE\"", "\"__ARM_FEATURE_SVE_BITS\"", "0", "\"__ARM_FEATURE_SVE_BITS\"", "\"__ARM_FEATURE_AES\"", "\"__ARM_FEATURE_SHA2\"", "\"__ARM_FEATURE_SHA3\"", "\"__ARM_FEATURE_SHA512\"", "\"__ARM_FEATURE_SM3\"", "\"__ARM_FEATURE_SM4\"", "\"__ARM_FEATURE_FP16_FML\"", "\"__FLT_EVAL_METHOD__\"", "\"__FLT_EVAL_METHOD__\"", "\"__FLT_EVAL_METHOD_C99__\"", "\"__FLT_EVAL_METHOD_C99__\"" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "isT", ")", ":", "ARMArchVersion", "(", "V4", ")", ",", "ARMFPUType", "(", "None", ")", ",", "UseNEONForSinglePrecisionFP", "(", "UseNEONFP", ")", ",", "IsThumb", "(", "isT", ")", ",", "ThumbMode", "(", "Thumb1", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "UseMOVT", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "\"generic\"", ")", ",", "TargetType", "(", "isELF", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "CPUString", "=", "ParseSubtargetFeatures", "(", "FS", ",", "CPUString", ")", ";", "if", "(", "CPUString", "==", "\"generic\"", "&&", "(", "FS", ".", "empty", "(", ")", "||", "FS", "==", "\"generic\"", ")", ")", "ARMArchVersion", "=", "V4T", ";", "unsigned", "Len", "=", "TT", ".", "length", "(", ")", ";", "unsigned", "Idx", "=", "0", ";", "if", "(", "Len", ">=", "5", "&&", "TT", ".", "substr", "(", "0", ",", "4", ")", "==", "\"armv\"", ")", "Idx", "=", "4", ";", "else", "if", "(", "Len", ">=", "6", "&&", "TT", ".", "substr", "(", "0", ",", "5", ")", "==", "\"thumb\"", ")", "{", "IsThumb", "=", "true", ";", "if", "(", "Len", ">=", "7", "&&", "TT", "[", "5", "]", "==", "'v'", ")", "Idx", "=", "6", ";", "}", "if", "(", "Idx", ")", "{", "unsigned", "SubVer", "=", "TT", "[", "Idx", "]", ";", "if", "(", "SubVer", ">=", "'7'", "&&", "SubVer", "<=", "'9'", ")", "{", "ARMArchVersion", "=", "V7A", ";", "}", "else", "if", "(", "SubVer", "==", "'6'", ")", "{", "ARMArchVersion", "=", "V6", ";", "if", "(", "Len", ">=", "Idx", "+", "3", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", "&&", "TT", "[", "Idx", "+", "2", "]", "==", "'2'", ")", "ARMArchVersion", "=", "V6T2", ";", "}", "else", "if", "(", "SubVer", "==", "'5'", ")", "{", "ARMArchVersion", "=", "V5T", ";", "if", "(", "Len", ">=", "Idx", "+", "3", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", "&&", "TT", "[", "Idx", "+", "2", "]", "==", "'e'", ")", "ARMArchVersion", "=", "V5TE", ";", "}", "else", "if", "(", "SubVer", "==", "'4'", ")", "{", "if", "(", "Len", ">=", "Idx", "+", "2", "&&", "TT", "[", "Idx", "+", "1", "]", "==", "'t'", ")", "ARMArchVersion", "=", "V4T", ";", "else", "ARMArchVersion", "=", "V4", ";", "}", "}", "if", "(", "ARMArchVersion", ">=", "V6T2", ")", "ThumbMode", "=", "Thumb2", ";", "else", "if", "(", "ThumbMode", ">=", "Thumb2", ")", "ARMArchVersion", "=", "V6T2", ";", "if", "(", "Len", ">=", "10", ")", "{", "if", "(", "TT", ".", "find", "(", "\"-darwin\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetType", "=", "isDarwin", ";", "}", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "IsR9Reserved", "=", "ReserveR9", "|", "(", "ARMArchVersion", "<", "V6", ")", ";", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "CPUString", "==", "\"cortex-a8\"", ")", "{", "if", "(", "UseNEONFP", ".", "getPosition", "(", ")", "==", "0", ")", "UseNEONForSinglePrecisionFP", "=", "true", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "4", "\"generic\"", "ARM", "\"generic\"", "\"generic\"", "ARM", "0", "5", "0", "4", "\"armv\"", "4", "6", "0", "5", "\"thumb\"", "7", "5", "6", "ARM", "ARM", "3", "1", "2", "ARM", "ARM", "3", "1", "2", "ARM", "2", "1", "ARM", "ARM", "ARM", "ARM", "10", "\"-darwin\"", "\"eabi\"", "ARM", "8", "ARM", "\"cortex-a8\"", "0" ]

[]

[ "<s>", "static", "tree", "builtin_quaternary_function_type", "(", "machine_mode", "mode_ret", ",", "machine_mode", "mode_arg0", ",", "machine_mode", "mode_arg1", ",", "machine_mode", "mode_arg2", ",", "machine_mode", "mode_arg3", ",", "enum", "rs6000_builtins", "builtin", ")", "{", "tree", "function_type", "=", "NULL", ";", "static", "tree", "v2udi_type", "=", "builtin_mode_to_type", "[", "V2DImode", "]", "[", "1", "]", ";", "static", "tree", "v16uqi_type", "=", "builtin_mode_to_type", "[", "V16QImode", "]", "[", "1", "]", ";", "static", "tree", "uchar_type", "=", "builtin_mode_to_type", "[", "QImode", "]", "[", "1", "]", ";", "static", "tree", "xxeval_type", "=", "build_function_type_list", "(", "v2udi_type", ",", "v2udi_type", ",", "v2udi_type", ",", "v2udi_type", ",", "uchar_type", ",", "NULL_TREE", ")", ";", "static", "tree", "xxpermx_type", "=", "build_function_type_list", "(", "v2udi_type", ",", "v2udi_type", ",", "v2udi_type", ",", "v16uqi_type", ",", "uchar_type", ",", "NULL_TREE", ")", ";", "switch", "(", "builtin", ")", "{", "case", "P10V_BUILTIN_XXEVAL", ":", "gcc_assert", "(", "(", "mode_ret", "==", "V2DImode", ")", "&&", "(", "mode_arg0", "==", "V2DImode", ")", "&&", "(", "mode_arg1", "==", "V2DImode", ")", "&&", "(", "mode_arg2", "==", "V2DImode", ")", "&&", "(", "mode_arg3", "==", "QImode", ")", ")", ";", "function_type", "=", "xxeval_type", ";", "break", ";", "case", "P10V_BUILTIN_VXXPERMX", ":", "gcc_assert", "(", "(", "mode_ret", "==", "V2DImode", ")", "&&", "(", "mode_arg0", "==", "V2DImode", ")", "&&", "(", "mode_arg1", "==", "V2DImode", ")", "&&", "(", "mode_arg2", "==", "V16QImode", ")", "&&", "(", "mode_arg3", "==", "QImode", ")", ")", ";", "function_type", "=", "xxpermx_type", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "function_type", ";", "}", "</s>" ]

[ "Map", "types", "for", "builtin", "functions", "with", "an", "explicit", "return", "type", "and", "exactly", "4", "arguments", ".", "Functions", "with", "fewer", "than", "3", "arguments", "use", "builtin_function_type", ".", "The", "number", "of", "quaternary", "built-in", "functions", "is", "very", "small", ".", "Handle", "each", "case", "specially", "." ]

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

[]

[ "<s>", "static", "bool", "expand_vec_perm_v4hi_5", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "char", "perm2", "[", "4", "]", ";", "rtx", "rmask", "[", "4", "]", ";", "unsigned", "i", ";", "rtx", "t0", ",", "t1", ",", "mask", ",", "x", ";", "bool", "ok", ";", "if", "(", "d", "->", "vmode", "!=", "V4HImode", "||", "d", "->", "one_operand_p", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "{", "perm2", "[", "i", "]", "=", "d", "->", "perm", "[", "i", "]", "&", "3", ";", "rmask", "[", "i", "]", "=", "(", "d", "->", "perm", "[", "i", "]", "&", "4", "?", "const0_rtx", ":", "constm1_rtx", ")", ";", "}", "mask", "=", "gen_rtx_CONST_VECTOR", "(", "V4HImode", ",", "gen_rtvec_v", "(", "4", ",", "rmask", ")", ")", ";", "mask", "=", "force_reg", "(", "V4HImode", ",", "mask", ")", ";", "t0", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "t1", "=", "gen_reg_rtx", "(", "V4HImode", ")", ";", "ok", "=", "expand_vselect", "(", "t0", ",", "d", "->", "op0", ",", "perm2", ",", "4", ")", ";", "gcc_assert", "(", "ok", ")", ";", "ok", "=", "expand_vselect", "(", "t1", ",", "d", "->", "op1", ",", "perm2", ",", "4", ")", ";", "gcc_assert", "(", "ok", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "mask", ",", "t0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t0", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "V4HImode", ",", "mask", ")", ";", "x", "=", "gen_rtx_AND", "(", "V4HImode", ",", "x", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "t1", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "V4HImode", ",", "t0", ",", "t1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "d", "->", "target", ",", "x", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ia64_expand_vec_perm_const_1", ".", "Emit", "a", "full", "V4HImode", "constant", "permutation", "via", "two", "mux2", "and", "a", "merge", "." ]

[ "ia64", "4", "4", "0", "4", "3", "4", "4", "4", "4" ]

[]

[ "<s>", "bool", "XNCMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "return", "true", ";", "}", "printSrcMemOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Load / Store Optimizer\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Load / Store Optimizer\"" ]

[]

[ "<s>", "bool", "XtensaFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "false", "&&", "\"XtensaFrameLowering::restoreCalleeSavedRegisters\"", "\" not implemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaFrameLowering::restoreCalleeSavedRegisters\"", "\" not implemented\"" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "TOC_RESTORE", ":", "return", "\"PPCISD::TOC_RESTORE\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "EXTSW_32", ":", "return", "\"PPCISD::EXTSW_32\"", ";", "case", "PPCISD", "::", "STD_32", ":", "return", "\"PPCISD::STD_32\"", ";", "case", "PPCISD", "::", "CALL_SVR4", ":", "return", "\"PPCISD::CALL_SVR4\"", ";", "case", "PPCISD", "::", "CALL_NOP_SVR4", ":", "return", "\"PPCISD::CALL_NOP_SVR4\"", ";", "case", "PPCISD", "::", "CALL_Darwin", ":", "return", "\"PPCISD::CALL_Darwin\"", ";", "case", "PPCISD", "::", "NOP", ":", "return", "\"PPCISD::NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL_Darwin", ":", "return", "\"PPCISD::BCTRL_Darwin\"", ";", "case", "PPCISD", "::", "BCTRL_SVR4", ":", "return", "\"PPCISD::BCTRL_SVR4\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "MFCR", ":", "return", "\"PPCISD::MFCR\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "MTFSB0", ":", "return", "\"PPCISD::MTFSB0\"", ";", "case", "PPCISD", "::", "MTFSB1", ":", "return", "\"PPCISD::MTFSB1\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "MTFSF", ":", "return", "\"PPCISD::MTFSF\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::TOC_RESTORE", "\"PPCISD::TOC_RESTORE\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::EXTSW_32", "\"PPCISD::EXTSW_32\"", "PPCISD::STD_32", "\"PPCISD::STD_32\"", "PPCISD::CALL_SVR4", "\"PPCISD::CALL_SVR4\"", "PPCISD::CALL_NOP_SVR4", "\"PPCISD::CALL_NOP_SVR4\"", "PPCISD::CALL_Darwin", "\"PPCISD::CALL_Darwin\"", "PPCISD::NOP", "\"PPCISD::NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL_Darwin", "\"PPCISD::BCTRL_Darwin\"", "PPCISD::BCTRL_SVR4", "\"PPCISD::BCTRL_SVR4\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::MFCR", "\"PPCISD::MFCR\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::MTFSB0", "\"PPCISD::MTFSB0\"", "PPCISD::MTFSB1", "\"PPCISD::MTFSB1\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::MTFSF", "\"PPCISD::MTFSF\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"" ]

[]

[ "<s>", "static", "bool", "s390_z10_optimize_cmp", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "prev_insn", ",", "*", "next_insn", ";", "bool", "insn_added_p", "=", "false", ";", "rtx", "cond", ",", "*", "op0", ",", "*", "op1", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", "{", "rtx", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "pattern", "||", "SET_DEST", "(", "pattern", ")", "!=", "pc_rtx", "||", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "IF_THEN_ELSE", ")", "return", "false", ";", "cond", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "0", ")", ";", "op0", "=", "&", "XEXP", "(", "cond", ",", "0", ")", ";", "op1", "=", "&", "XEXP", "(", "cond", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "{", "rtx", "src", ",", "dest", ";", "src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "dest", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "if", "(", "!", "REG_P", "(", "dest", ")", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "dest", ")", ")", "||", "GET_CODE", "(", "src", ")", "!=", "COMPARE", ")", "return", "false", ";", "cond", "=", "NULL_RTX", ";", "op0", "=", "&", "XEXP", "(", "src", ",", "0", ")", ";", "op1", "=", "&", "XEXP", "(", "src", ",", "1", ")", ";", "}", "else", "return", "false", ";", "if", "(", "!", "REG_P", "(", "*", "op0", ")", "||", "!", "REG_P", "(", "*", "op1", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "*", "op0", ")", ")", "!=", "MODE_INT", ")", "return", "false", ";", "prev_insn", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "prev_insn", "!=", "NULL_RTX", "&&", "INSN_P", "(", "prev_insn", ")", "&&", "reg_referenced_p", "(", "*", "op1", ",", "PATTERN", "(", "prev_insn", ")", ")", ")", "s390_swap_cmp", "(", "cond", ",", "op0", ",", "op1", ",", "insn", ")", ";", "next_insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "next_insn", "!=", "NULL_RTX", "&&", "INSN_P", "(", "next_insn", ")", "&&", "s390_non_addr_reg_read_p", "(", "*", "op1", ",", "next_insn", ")", ")", "{", "if", "(", "prev_insn", "!=", "NULL_RTX", "&&", "INSN_P", "(", "prev_insn", ")", "&&", "s390_non_addr_reg_read_p", "(", "*", "op0", ",", "prev_insn", ")", ")", "{", "if", "(", "REGNO", "(", "*", "op1", ")", "==", "0", ")", "emit_insn_after", "(", "gen_nop_lr1", "(", ")", ",", "insn", ")", ";", "else", "emit_insn_after", "(", "gen_nop_lr0", "(", ")", ",", "insn", ")", ";", "insn_added_p", "=", "true", ";", "}", "else", "s390_swap_cmp", "(", "cond", ",", "op0", ",", "op1", ",", "insn", ")", ";", "}", "return", "insn_added_p", ";", "}", "</s>" ]

[ "On", "z10", ",", "instructions", "of", "the", "compare-and-branch", "family", "have", "the", "property", "to", "access", "the", "register", "occurring", "as", "second", "operand", "with", "its", "bits", "complemented", ".", "If", "such", "a", "compare", "is", "grouped", "with", "a", "second", "instruction", "that", "accesses", "the", "same", "register", "non-complemented", ",", "and", "if", "that", "register", "'s", "value", "is", "delivered", "via", "a", "bypass", ",", "then", "the", "pipeline", "recycles", ",", "thereby", "causing", "significant", "performance", "decline", ".", "This", "function", "locates", "such", "situations", "and", "exchanges", "the", "two", "operands", "of", "the", "compare", ".", "The", "function", "return", "true", "whenever", "it", "added", "an", "insn", "." ]

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

[]

[ "<s>", "static", "rtx", "F", "(", "rtx", "x", ")", "{", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "We", "use", "this", "to", "wrap", "all", "emitted", "insns", "in", "the", "prologue", ",", "so", "they", "get", "the", "``", "frame-related", "''", "(", "/f", ")", "flag", "set", "." ]

[ "msp430", "1" ]

[]

[ "<s>", "static", "inline", "rtx", "force_mode", "(", "machine_mode", "mode", ",", "rtx", "orig", ")", "{", "if", "(", "mode", "==", "GET_MODE", "(", "orig", ")", ")", "return", "orig", ";", "gcc_assert", "(", "REGNO", "(", "orig", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "orig", ")", ")", ";", "}", "</s>" ]

[ "Ensure", "mode", "of", "ORIG", ",", "a", "REG", "rtx", ",", "is", "MODE", ".", "Returns", "either", "ORIG", "or", "a", "new", "rtx", "with", "the", "correct", "mode", "." ]

[ "pa" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "return", "TII", "->", "isInlineConstant", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "R600", "SI", "SI", "SI" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "getAMDGPUTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "return", "createR600MachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "const", "uint16_t", "*", "Dcpu16RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "Dcpu16", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "LEGRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "CC_Save_RegMask", ";", "}", "</s>" ]

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

[ "LEG", "LEG" ]

[]

[ "<s>", "static", "bool", "aarch64_simd_vector_alignment_reachable", "(", "const_tree", "type", ",", "bool", "is_packed", ")", "{", "if", "(", "is_packed", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "(", "wi", "::", "to_widest", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "aarch64_vectorize_preferred_vector_alignment", "(", "type", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE", "." ]

[ "aarch64" ]

[]

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

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

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

[]

[ "<s>", "void", "ARMDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "if", "(", "!", "Subtarget", "->", "hasV6T2Ops", "(", ")", ")", "return", ";", "bool", "isThumb2", "=", "Subtarget", "->", "isThumb", "(", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "continue", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "And_imm", "=", "0", ";", "if", "(", "!", "isOpcWithIntImmediate", "(", "N1", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", ")", "{", "if", "(", "isOpcWithIntImmediate", "(", "N0", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", ")", "std", "::", "swap", "(", "N0", ",", "N1", ")", ";", "}", "if", "(", "!", "And_imm", ")", "continue", ";", "unsigned", "TZ", "=", "CountTrailingZeros_32", "(", "And_imm", ")", ";", "if", "(", "TZ", "!=", "1", "&&", "TZ", "!=", "2", ")", "continue", ";", "And_imm", ">>=", "TZ", ";", "if", "(", "And_imm", "&", "(", "And_imm", "+", "1", ")", ")", "continue", ";", "SDValue", "Srl", "=", "N1", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Srl_imm", "=", "0", ";", "if", "(", "!", "isOpcWithIntImmediate", "(", "Srl", ".", "getNode", "(", ")", ",", "ISD", "::", "SRL", ",", "Srl_imm", ")", "||", "(", "Srl_imm", "<=", "2", ")", ")", "continue", ";", "SDValue", "CPTmp0", ";", "SDValue", "CPTmp1", ";", "SDValue", "CPTmp2", ";", "if", "(", "isThumb2", ")", "{", "if", "(", "SelectT2ShifterOperandReg", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ")", ")", "continue", ";", "}", "else", "{", "if", "(", "SelectImmShifterOperand", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ")", "||", "SelectRegShifterOperand", "(", "N0", ",", "CPTmp0", ",", "CPTmp1", ",", "CPTmp2", ")", ")", "continue", ";", "}", "Srl", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SRL", ",", "Srl", ".", "getDebugLoc", "(", ")", ",", "MVT", "::", "i32", ",", "Srl", ".", "getOperand", "(", "0", ")", ",", "CurDAG", "->", "getConstant", "(", "Srl_imm", "+", "TZ", ",", "MVT", "::", "i32", ")", ")", ";", "N1", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "AND", ",", "N1", ".", "getDebugLoc", "(", ")", ",", "MVT", "::", "i32", ",", "Srl", ",", "CurDAG", "->", "getConstant", "(", "And_imm", ",", "MVT", "::", "i32", ")", ")", ";", "N1", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SHL", ",", "N1", ".", "getDebugLoc", "(", ")", ",", "MVT", "::", "i32", ",", "N1", ",", "CurDAG", "->", "getConstant", "(", "TZ", ",", "MVT", "::", "i32", ")", ")", ";", "CurDAG", "->", "UpdateNodeOperands", "(", "N", ",", "N0", ",", "N1", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "ARM", "ARM", "ISD::ADD", "0", "1", "0", "ISD::AND", "ISD::AND", "1", "2", "1", "0", "0", "ISD::SRL", "2", "ISD::SRL", "MVT::i32", "0", "MVT::i32", "ISD::AND", "MVT::i32", "MVT::i32", "ISD::SHL", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "MCSection", "*", "MipsTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "IsConstantInSmallSection", "(", "DL", ",", "C", ",", "*", "TM", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createARMMachObjectWriter", "(", "OS", ",", "false", ",", "MachO", "::", "CPU_TYPE_ARM", ",", "Subtype", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "XCoreGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", "{", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "XCore", "XCore", "XCore", "XCore" ]

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "TailCall", ":", "return", "\"MipsISD::TailCall\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "ThreadPointer", ":", "return", "\"MipsISD::ThreadPointer\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "EH_RETURN", ":", "return", "\"MipsISD::EH_RETURN\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "\"MipsISD::CMovFP_T\"", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "return", "\"MipsISD::CMovFP_F\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "case", "MipsISD", "::", "MAdd", ":", "return", "\"MipsISD::MAdd\"", ";", "case", "MipsISD", "::", "MAddu", ":", "return", "\"MipsISD::MAddu\"", ";", "case", "MipsISD", "::", "MSub", ":", "return", "\"MipsISD::MSub\"", ";", "case", "MipsISD", "::", "MSubu", ":", "return", "\"MipsISD::MSubu\"", ";", "case", "MipsISD", "::", "DivRem", ":", "return", "\"MipsISD::DivRem\"", ";", "case", "MipsISD", "::", "DivRemU", ":", "return", "\"MipsISD::DivRemU\"", ";", "case", "MipsISD", "::", "BuildPairF64", ":", "return", "\"MipsISD::BuildPairF64\"", ";", "case", "MipsISD", "::", "ExtractElementF64", ":", "return", "\"MipsISD::ExtractElementF64\"", ";", "case", "MipsISD", "::", "Wrapper", ":", "return", "\"MipsISD::Wrapper\"", ";", "case", "MipsISD", "::", "Sync", ":", "return", "\"MipsISD::Sync\"", ";", "case", "MipsISD", "::", "Ext", ":", "return", "\"MipsISD::Ext\"", ";", "case", "MipsISD", "::", "Ins", ":", "return", "\"MipsISD::Ins\"", ";", "case", "MipsISD", "::", "LWL", ":", "return", "\"MipsISD::LWL\"", ";", "case", "MipsISD", "::", "LWR", ":", "return", "\"MipsISD::LWR\"", ";", "case", "MipsISD", "::", "SWL", ":", "return", "\"MipsISD::SWL\"", ";", "case", "MipsISD", "::", "SWR", ":", "return", "\"MipsISD::SWR\"", ";", "case", "MipsISD", "::", "LDL", ":", "return", "\"MipsISD::LDL\"", ";", "case", "MipsISD", "::", "LDR", ":", "return", "\"MipsISD::LDR\"", ";", "case", "MipsISD", "::", "SDL", ":", "return", "\"MipsISD::SDL\"", ";", "case", "MipsISD", "::", "SDR", ":", "return", "\"MipsISD::SDR\"", ";", "case", "MipsISD", "::", "EXTP", ":", "return", "\"MipsISD::EXTP\"", ";", "case", "MipsISD", "::", "EXTPDP", ":", "return", "\"MipsISD::EXTPDP\"", ";", "case", "MipsISD", "::", "EXTR_S_H", ":", "return", "\"MipsISD::EXTR_S_H\"", ";", "case", "MipsISD", "::", "EXTR_W", ":", "return", "\"MipsISD::EXTR_W\"", ";", "case", "MipsISD", "::", "EXTR_R_W", ":", "return", "\"MipsISD::EXTR_R_W\"", ";", "case", "MipsISD", "::", "EXTR_RS_W", ":", "return", "\"MipsISD::EXTR_RS_W\"", ";", "case", "MipsISD", "::", "SHILO", ":", "return", "\"MipsISD::SHILO\"", ";", "case", "MipsISD", "::", "MTHLIP", ":", "return", "\"MipsISD::MTHLIP\"", ";", "case", "MipsISD", "::", "MULT", ":", "return", "\"MipsISD::MULT\"", ";", "case", "MipsISD", "::", "MULTU", ":", "return", "\"MipsISD::MULTU\"", ";", "case", "MipsISD", "::", "MADD_DSP", ":", "return", "\"MipsISD::MADD_DSPDSP\"", ";", "case", "MipsISD", "::", "MADDU_DSP", ":", "return", "\"MipsISD::MADDU_DSP\"", ";", "case", "MipsISD", "::", "MSUB_DSP", ":", "return", "\"MipsISD::MSUB_DSP\"", ";", "case", "MipsISD", "::", "MSUBU_DSP", ":", "return", "\"MipsISD::MSUBU_DSP\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::TailCall", "\"MipsISD::TailCall\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::ThreadPointer", "\"MipsISD::ThreadPointer\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::EH_RETURN", "\"MipsISD::EH_RETURN\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::CMovFP_T", "\"MipsISD::CMovFP_T\"", "MipsISD::CMovFP_F", "\"MipsISD::CMovFP_F\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"", "MipsISD::MAdd", "\"MipsISD::MAdd\"", "MipsISD::MAddu", "\"MipsISD::MAddu\"", "MipsISD::MSub", "\"MipsISD::MSub\"", "MipsISD::MSubu", "\"MipsISD::MSubu\"", "MipsISD::DivRem", "\"MipsISD::DivRem\"", "MipsISD::DivRemU", "\"MipsISD::DivRemU\"", "MipsISD::BuildPairF64", "\"MipsISD::BuildPairF64\"", "MipsISD::ExtractElementF64", "\"MipsISD::ExtractElementF64\"", "MipsISD::Wrapper", "\"MipsISD::Wrapper\"", "MipsISD::Sync", "\"MipsISD::Sync\"", "MipsISD::Ext", "\"MipsISD::Ext\"", "MipsISD::Ins", "\"MipsISD::Ins\"", "MipsISD::LWL", "\"MipsISD::LWL\"", "MipsISD::LWR", "\"MipsISD::LWR\"", "MipsISD::SWL", "\"MipsISD::SWL\"", "MipsISD::SWR", "\"MipsISD::SWR\"", "MipsISD::LDL", "\"MipsISD::LDL\"", "MipsISD::LDR", "\"MipsISD::LDR\"", "MipsISD::SDL", "\"MipsISD::SDL\"", "MipsISD::SDR", "\"MipsISD::SDR\"", "MipsISD::EXTP", "\"MipsISD::EXTP\"", "MipsISD::EXTPDP", "\"MipsISD::EXTPDP\"", "MipsISD::EXTR_S_H", "\"MipsISD::EXTR_S_H\"", "MipsISD::EXTR_W", "\"MipsISD::EXTR_W\"", "MipsISD::EXTR_R_W", "\"MipsISD::EXTR_R_W\"", "MipsISD::EXTR_RS_W", "\"MipsISD::EXTR_RS_W\"", "MipsISD::SHILO", "\"MipsISD::SHILO\"", "MipsISD::MTHLIP", "\"MipsISD::MTHLIP\"", "MipsISD::MULT", "\"MipsISD::MULT\"", "MipsISD::MULTU", "\"MipsISD::MULTU\"", "MipsISD::MADD_DSP", "\"MipsISD::MADD_DSPDSP\"", "MipsISD::MADDU_DSP", "\"MipsISD::MADDU_DSP\"", "MipsISD::MSUB_DSP", "\"MipsISD::MSUB_DSP\"", "MipsISD::MSUBU_DSP", "\"MipsISD::MSUBU_DSP\"" ]

[]

[ "<s>", "void", "print", "(", "const", "TargetRegisterInfo", "*", "TRI", "=", "nullptr", ")", "const", "{", "dbgs", "(", ")", "<<", "PrintReg", "(", "Reg", ",", "TRI", ",", "SubReg", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "rs6000_live_on_entry", "(", "bitmap", "regs", ")", "{", "if", "(", "flag_split_stack", ")", "bitmap_set_bit", "(", "regs", ",", "12", ")", ";", "}", "</s>" ]

[ "We", "may", "have", "to", "tell", "the", "dataflow", "pass", "that", "the", "split", "stack", "prologue", "is", "initializing", "a", "register", "." ]

[ "rs6000", "12" ]

[]

[ "<s>", "const", "CallLowering", "*", "AArch64Subtarget", "::", "getCallLowering", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getCallLowering", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "AArch64", "AArch64", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "SparcELFTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "dwarf", "::", "DW_EH_PE_pcrel", ")", "{", "MachineModuleInfoELF", "&", "ELFMMI", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MCSymbol", "*", "SSym", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "\".DW.stub\"", ",", "Mang", ",", "TM", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "ELFMMI", ".", "getGVStubEntry", "(", "SSym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Sym", ",", "!", "GV", "->", "hasLocalLinkage", "(", ")", ")", ";", "}", "MCContext", "&", "Ctx", "=", "getContext", "(", ")", ";", "return", "SparcMCExpr", "::", "create", "(", "SparcMCExpr", "::", "VK_Sparc_R_DISP32", ",", "MCSymbolRefExpr", "::", "create", "(", "SSym", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "Sparc", "Sparc", "\".DW.stub\"", "Sparc", "Sparc", "SP" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "RISCVMCExpr", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Opc", ";", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_S", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_D", ";", "else", "if", "(", "RISCV", "::", "VGRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "RISCV", "::", "VPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "RISCV", "::", "VQRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "RISCV", "::", "VORRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "(", "RISCV", "::", "VMASKRegClass", ".", "contains", "(", "DstReg", ")", "&&", "RISCV", "::", "VGRRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "Opc", "=", "RISCV", "::", "VMV_V_V", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "RISCV", "::", "V0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FPR64RegClass", "RISCV::FSGNJ_D", "RISCV::VGRRegClass", "RISCV::VPRRegClass", "RISCV::VQRRegClass", "RISCV::VORRegClass", "RISCV::VMASKRegClass", "RISCV::VGRRegClass", "RISCV::VMV_V_V", "RISCV::V0", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "if", "(", "AddrMode", "==", "ARMII", "::", "AddrMode4", "||", "AddrMode", "==", "ARMII", "::", "AddrMode6", ")", "return", "Offset", "==", "0", ";", "unsigned", "NumBits", "=", "0", ";", "unsigned", "Scale", "=", "1", ";", "bool", "isSigned", "=", "true", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "Scale", "=", "1", ";", "if", "(", "Offset", "<", "0", ")", "{", "NumBits", "=", "8", ";", "Offset", "=", "-", "Offset", ";", "}", "else", "{", "NumBits", "=", "12", ";", "}", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "NumBits", "=", "8", ";", "Scale", "=", "4", ";", "break", ";", "case", "ARMII", "::", "AddrMode_i12", ":", "case", "ARMII", "::", "AddrMode2", ":", "NumBits", "=", "12", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "NumBits", "=", "8", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "NumBits", "=", "(", "BaseReg", "==", "ARM", "::", "SP", "?", "8", ":", "5", ")", ";", "Scale", "=", "4", ";", "isSigned", "=", "false", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "}", "Offset", "+=", "getFrameIndexInstrOffset", "(", "MI", ",", "i", ")", ";", "if", "(", "(", "Offset", "&", "(", "Scale", "-", "1", ")", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "isSigned", "&&", "Offset", "<", "0", ")", "Offset", "=", "-", "Offset", ";", "unsigned", "Mask", "=", "(", "1", "<<", "NumBits", ")", "-", "1", ";", "if", "(", "(", "unsigned", ")", "Offset", "<=", "Mask", "*", "Scale", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARMII::AddrMode4", "ARMII::AddrMode6", "0", "0", "1", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "1", "0", "8", "12", "ARMII::AddrMode5", "8", "4", "ARMII::AddrMode_i12", "ARMII::AddrMode2", "12", "ARMII::AddrMode3", "8", "ARMII::AddrModeT1_s", "ARM::SP", "8", "5", "4", "\"Unsupported addressing mode!\"", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "neon_const_bounds", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ")", "{", "bounds_check", "(", "operand", ",", "low", ",", "high", ",", "\"constant out of range\"", ")", ";", "}", "</s>" ]

[ "Bounds-check", "constants", "." ]

[ "arm", "\"constant out of range\"" ]

[]

[ "<s>", "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "unsigned", "SubReg", "=", "MO", ".", "getSubReg", "(", ")", ")", "{", "assert", "(", "RI", ".", "getRegSizeInBits", "(", "*", "RI", ".", "getSubClassWithSubReg", "(", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ",", "SubReg", ")", ")", ">=", "32", "&&", "\"Sub-dword subregs are not supported\"", ")", ";", "return", "RI", ".", "getNumChannelsFromSubReg", "(", "SubReg", ")", "*", "4", ";", "}", "}", "return", "RI", ".", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "MI", ",", "OpNo", ")", ")", "/", "8", ";", "}", "</s>" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "AMDGPU", "32", "\"Sub-dword subregs are not supported\"", "4", "8" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "MipsABIInfo", "::", "GetVarArgRegs", "(", ")", "const", "{", "if", "(", "IsCheriPureCap", "(", ")", ")", "return", "makeArrayRef", "(", "CheriCapArgRegs", ")", ";", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "makeArrayRef", "(", "Mips64IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "the", "variable", "argument", "list", "." ]

[ "Mips", "Mips", "Mips", "\"Unhandled ABI\"" ]

[]

[ "<s>", "static", "bool", "bfin_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "enum", "reg_class", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "false", ";", "if", "(", "mode", "==", "V2HImode", ")", "return", "D_REGNO_P", "(", "regno", ")", ";", "if", "(", "rclass", "==", "CCREGS", ")", "return", "mode", "==", "BImode", ";", "if", "(", "mode", "==", "PDImode", "||", "mode", "==", "V2PDImode", ")", "return", "regno", "==", "REG_A0", "||", "regno", "==", "REG_A1", ";", "if", "(", "mode", "==", "DImode", ")", "return", "regno", "<", "REG_M3", ";", "if", "(", "mode", "==", "SImode", "&&", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "PROLOGUE_REGS", "]", ",", "regno", ")", ")", "return", "true", ";", "return", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "MOST_REGS", "]", ",", "regno", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "Do", "not", "allow", "to", "store", "a", "value", "in", "REG_CC", "for", "any", "mode", ".", "Do", "not", "allow", "to", "store", "value", "in", "pregs", "if", "mode", "is", "not", "SI", "." ]

[ "bfin" ]

[]

[ "<s>", "static", "unsigned", "getHashValue", "(", "const", "TOCKey", "&", "PairVal", ")", "{", "return", "detail", "::", "combineHashValue", "(", "DenseMapInfo", "<", "const", "MCSymbol", "*", ">", "::", "getHashValue", "(", "PairVal", ".", "first", ")", ",", "DenseMapInfo", "<", "int", ">", "::", "getHashValue", "(", "PairVal", ".", "second", ")", ")", ";", "}", "</s>" ]

[ "Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "Align", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "-", "CalleePopAmount", ",", "TII", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "0", "}", ";", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "*", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "CalleeSavedRegsFP", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "0", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "0", "XCore" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64MIPeepholeOptPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "static", "bool", "is_load_insn", "(", "rtx", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "return", "false", ";", "return", "is_load_insn1", "(", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Determine", "if", "INSN", "loads", "from", "memory", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "char", "*", "vfp_output_fstmx", "(", "rtx", "*", "operands", ")", "{", "char", "pattern", "[", "100", "]", ";", "int", "p", ";", "int", "base", ";", "int", "i", ";", "strcpy", "(", "pattern", ",", "\"fstmfdx\\t%m0!, {%P1\"", ")", ";", "p", "=", "strlen", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", ")", ";", "base", "=", "(", "REGNO", "(", "operands", "[", "1", "]", ")", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ";", "for", "(", "i", "=", "1", ";", "i", "<", "XVECLEN", "(", "operands", "[", "2", "]", ",", "0", ")", ";", "i", "++", ")", "{", "p", "+=", "sprintf", "(", "&", "pattern", "[", "p", "]", ",", "\", d%d\"", ",", "base", "+", "i", ")", ";", "}", "strcpy", "(", "&", "pattern", "[", "p", "]", ",", "\"}\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "store", "multiple", "." ]

[ "arm", "100", "\"fstmfdx\\t%m0!, {%P1\"", "1", "1", "2", "1", "2", "0", "\", d%d\"", "\"}\"", "\"\"" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FP", ":", "MSP430", "::", "SP", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "MSP430::FP", "MSP430::SP", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

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

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

[ "OR1K" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZElimComparePass", "(", "getSystemZTargetMachine", "(", ")", ")", ",", "false", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZShortenInstPass", "(", "getSystemZTargetMachine", "(", ")", ")", ",", "false", ")", ";", "addPass", "(", "createSystemZLongBranchPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\" mods: \"", "<<", "Reg", ".", "Mods", "<<", "'>'", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "'<'", "<<", "getImm", "(", ")", ";", "if", "(", "getImmTy", "(", ")", "!=", "ImmTyNone", ")", "{", "OS", "<<", "\" type: \"", ";", "printImmTy", "(", "OS", ",", "getImmTy", "(", ")", ")", ";", "}", "OS", "<<", "\" mods: \"", "<<", "Imm", ".", "Mods", "<<", "'>'", ";", "break", ";", "case", "Token", ":", "OS", "<<", "'\\''", "<<", "getToken", "(", ")", "<<", "'\\''", ";", "break", ";", "case", "Expression", ":", "OS", "<<", "\"<expr \"", "<<", "*", "Expr", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "\"<register \"", "\" mods: \"", "\" type: \"", "\" mods: \"", "\"<expr \"" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "lra_in_progress", "&&", "mode", "==", "SDmode", ")", "return", "DDmode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "mode", "to", "be", "used", "for", "memory", "when", "a", "secondary", "memory", "location", "is", "needed", ".", "For", "SDmode", "values", "we", "need", "to", "use", "DDmode", ",", "in", "all", "other", "cases", "we", "can", "use", "the", "same", "mode", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "bool", "v850_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CAN_ELIMINATE", "." ]

[ "v850" ]

[]

[ "<s>", "const", "MCExpr", "*", "AArch64_MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";", "MCSymbol", "*", "PCSym", "=", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "Streamer", ".", "emitLabel", "(", "PCSym", ")", ";", "const", "MCExpr", "*", "PC", "=", "MCSymbolRefExpr", "::", "create", "(", "PCSym", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "createSub", "(", "Res", ",", "PC", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "SUnit", "*", "GCNMaxOccupancySchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "do", "{", "if", "(", "RegionPolicy", ".", "OnlyTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "TopCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Top", ",", "NoPolicy", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "RegionPolicy", ".", "OnlyBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "BotCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Bot", ",", "NoPolicy", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidirectional", "(", "IsTopNode", ")", ";", "}", "}", "while", "(", "SU", "->", "isScheduled", ")", ";", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", "<<", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "AMDGPU", "\"ReadyQ garbage\"", "\"failed to find a candidate\"", "\"failed to find a candidate\"", "\"Scheduling SU(\"", "\") \"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableDeadRegisterElimination", ")", "addPass", "(", "createAArch64DeadRegisterDefinitions", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAdvSIMDScalar", ")", "{", "addPass", "(", "createAArch64AdvSIMDScalar", "(", ")", ")", ";", "addPass", "(", "&", "PeepholeOptimizerID", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyCallIndirectFixup", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "sh_unspec_insn_p", "(", "rtx", "x", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "i", ",", "array", ",", "x", ",", "ALL", ")", "if", "(", "*", "i", "!=", "NULL", "&&", "(", "GET_CODE", "(", "*", "i", ")", "==", "UNSPEC", "||", "GET_CODE", "(", "*", "i", ")", "==", "UNSPEC_VOLATILE", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "insn", "contains", "any", "UNSPECs", "or", "UNSPEC_VOLATILEs", "." ]

[ "sh" ]

[]

[ "<s>", "const", "char", "*", "aarch64_gen_far_branch", "(", "rtx", "*", "operands", ",", "int", "pos_label", ",", "const", "char", "*", "dest", ",", "const", "char", "*", "branch_format", ")", "{", "rtx_code_label", "*", "tmp_label", "=", "gen_label_rtx", "(", ")", ";", "char", "label_buf", "[", "256", "]", ";", "char", "buffer", "[", "128", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label_buf", ",", "dest", ",", "CODE_LABEL_NUMBER", "(", "tmp_label", ")", ")", ";", "const", "char", "*", "label_ptr", "=", "targetm", ".", "strip_name_encoding", "(", "label_buf", ")", ";", "rtx", "dest_label", "=", "operands", "[", "pos_label", "]", ";", "operands", "[", "pos_label", "]", "=", "tmp_label", ";", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"%s%s\"", ",", "branch_format", ",", "label_ptr", ")", ";", "output_asm_insn", "(", "buffer", ",", "operands", ")", ";", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"b\\t%%l%d\\n%s:\"", ",", "pos_label", ",", "label_ptr", ")", ";", "operands", "[", "pos_label", "]", "=", "dest_label", ";", "output_asm_insn", "(", "buffer", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Generate", "code", "to", "enable", "conditional", "branches", "in", "functions", "over", "1", "MiB", "." ]

[ "aarch64", "256", "128", "\"%s%s\"", "\"b\\t%%l%d\\n%s:\"", "\"\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "ADD_F128", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "SUB_F128", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "MUL_F128", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "DIV_F128", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerFP_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "getSubtarget", "(", ")", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom lower this!\"", "ISD::FADD", "ISD::FSUB", "ISD::FMUL", "ISD::FDIV", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_ROUND", "ISD::FP_EXTEND", "ISD::BlockAddress", "ISD::BRCOND", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VACOPY", "ISD::VASTART", "ISD::BUILD_VECTOR" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseReg", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "LdSt", ".", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "!=", "3", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "Width", "=", "(", "*", "LdSt", ".", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", ";", "BaseReg", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "RISCV", "RISCV", "3", "1", "2", "1", "2" ]

[]

[ "<s>", "bool", "SIFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", ")", "{", "if", "(", "MFI", ".", "getStackSize", "(", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "isEntryFunction", "(", ")", ")", "return", "true", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "}", "return", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "OW", "->", "WriteZeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Z80" ]

[]

[ "<s>", "void", "riscv_init_builtins", "(", "void", ")", "{", "riscv_init_builtin_types", "(", ")", ";", "riscv_vector", "::", "init_builtins", "(", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "riscv_builtins", ")", ";", "i", "++", ")", "{", "const", "struct", "riscv_builtin_description", "*", "d", "=", "&", "riscv_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "{", "tree", "type", "=", "riscv_build_function_type", "(", "d", "->", "prototype", ")", ";", "riscv_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "type", ",", "(", "i", "<<", "RISCV_BUILTIN_SHIFT", ")", "+", "RISCV_BUILTIN_GENERAL", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "riscv_builtin_decl_index", "[", "d", "->", "icode", "]", "=", "i", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "riscv", "riscv_vector::init_builtins", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDE", ":", "return", "PerformADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "PerformSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "PerformDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "Mips", "Mips", "ISD::ADDE", "ISD::SUBE", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SETCC", "ISD::AND", "ISD::OR" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "XOR32rr", ")", ")", ";", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0B", ":", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV32r0", "X86::XOR32rr", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::AVX512_512_SET0", "X86::VPXORDZrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri", "X86::KSET0B", "X86::KSET0W", "X86::KXORWrr", "X86::KSET1B", "X86::KSET1W", "X86::KXNORWrr" ]

[]

[ "<s>", "SDValue", "WebAssemblySelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Val", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "IsVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "hasBulkMemory", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "MemIdx", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "MEMORY_FILL", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ",", "MemIdx", ",", "Dst", ",", "DAG", ".", "getAnyExtOrTrunc", "(", "Val", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getZExtOrTrunc", "(", "Size", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "MVT::i32", "WebAssemblyISD::MEMORY_FILL", "MVT::Other", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "static", "unsigned", "aarch64_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "unsigned", "*", "cost", "=", "(", "unsigned", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "aarch64_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", "->", "pred_begin", "(", ")", ";", "if", "(", "const", "BasicBlock", "*", "bb", "=", "Pred", "->", "getBasicBlock", "(", ")", ")", "if", "(", "isa", "<", "SwitchInst", ">", "(", "bb", "->", "getTerminator", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "AsmPrinterisBlockOnlyReachableByFallthrough", "(", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "OR1K" ]

[]

[ "<s>", "OffsetRange", "&", "shift", "(", "int32_t", "S", ")", "{", "Min", "+=", "S", ";", "Max", "+=", "S", ";", "Offset", "=", "(", "Offset", "+", "S", ")", "%", "Align", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "Create", "a", "new", "AAMDNode", "that", "describes", "this", "AAMDNode", "after", "applying", "a", "constant", "offset", "to", "the", "start", "of", "the", "pointer", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_sve_adjust_stmt_cost", "(", "class", "vec_info", "*", "vinfo", ",", "vect_cost_for_stmt", "kind", ",", "stmt_vec_info", "stmt_info", ",", "tree", "vectype", ",", "unsigned", "int", "stmt_cost", ")", "{", "if", "(", "kind", "==", "vector_stmt", "&&", "aarch64_extending_load_p", "(", "vinfo", ",", "stmt_info", ")", ")", "stmt_cost", "=", "0", ";", "if", "(", "kind", "==", "vector_stmt", "&&", "aarch64_integer_truncation_p", "(", "stmt_info", ")", ")", "stmt_cost", "=", "0", ";", "if", "(", "STMT_VINFO_GROUPED_ACCESS", "(", "stmt_info", ")", ")", "{", "stmt_vec_info", "first", "=", "DR_GROUP_FIRST_ELEMENT", "(", "stmt_info", ")", ";", "unsigned", "int", "count", "=", "DR_GROUP_SIZE", "(", "first", ")", "-", "DR_GROUP_GAP", "(", "first", ")", ";", "unsigned", "int", "elt_bits", "=", "GET_MODE_UNIT_BITSIZE", "(", "TYPE_MODE", "(", "vectype", ")", ")", ";", "if", "(", "multiple_p", "(", "count", "*", "elt_bits", ",", "256", ")", "&&", "aarch64_advsimd_ldp_stp_p", "(", "kind", ",", "stmt_info", ")", ")", "stmt_cost", "*=", "2", ";", "}", "return", "stmt_cost", ";", "}", "</s>" ]

[ "STMT_COST", "is", "the", "cost", "calculated", "by", "aarch64_builtin_vectorization_cost", "for", "STMT_INFO", ",", "which", "has", "cost", "kind", "KIND", "and", "which", "when", "vectorized", "would", "operate", "on", "vector", "type", "VECTYPE", ".", "Adjust", "the", "cost", "as", "necessary", "for", "SVE", "targets", "." ]

[ "aarch64", "0", "0", "256", "2" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "ID", "==", "Intrinsic", "::", "bswap", "&&", "ST", "->", "hasP9Vector", "(", ")", ")", "return", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ".", "first", ";", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Tys", ",", "FMF", ",", "ScalarizationCostPassed", ",", "I", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "PowerPC", "PPC", "Intrinsic::ID", "Intrinsic::bswap" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"WorkItem, iMask = \"", "<<", "Mask", "<<", "\" :\\n\"", ";", "for", "(", "auto", "TI", ":", "Items", ")", "TI", "->", "dump", "(", ")", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "TPC", "\"WorkItem, iMask = \"", "\" :\\n\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "!", "EnableCheri128FailHard", ")", "return", "false", ";", "InstrInfo", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "16", ">", "instrs", ";", "std", "::", "set", "<", "MachineBasicBlock", "*", ">", "bbs", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "CIncOffset", ")", "||", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "CSetOffset", ")", ")", "{", "instrs", ".", "push_back", "(", "&", "MI", ")", ";", "bbs", ".", "insert", "(", "&", "MBB", ")", ";", "}", "if", "(", "instrs", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "*", "MI", ":", "instrs", ")", "{", "Register", "tag_before", "=", "RI", ".", "createVirtualRegister", "(", "&", "Mips", "::", "GPR64RegClass", ")", ";", "Register", "tag_after", "=", "RI", ".", "createVirtualRegister", "(", "&", "Mips", "::", "GPR64RegClass", ")", ";", "auto", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "InstrInfo", "->", "get", "(", "Mips", "::", "CGetTag", ")", ")", ".", "addDef", "(", "tag_before", ")", ".", "addUse", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "after", "=", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "++", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "InstrInfo", "->", "get", "(", "Mips", "::", "CGetTag", ")", ")", ".", "addDef", "(", "tag_after", ")", ".", "addUse", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getInstr", "(", ")", ";", "auto", "Sink", "=", "MF", ".", "CreateMachineBasicBlock", "(", "MBB", ".", "getBasicBlock", "(", ")", ")", ";", "MF", ".", "insert", "(", "++", "MachineFunction", "::", "iterator", "(", "MBB", ")", ",", "Sink", ")", ";", "Sink", "->", "splice", "(", "Sink", "->", "begin", "(", ")", ",", "&", "MBB", ",", "std", "::", "next", "(", "after", ")", ",", "MBB", ".", "end", "(", ")", ")", ";", "Sink", "->", "transferSuccessorsAndUpdatePHIs", "(", "&", "MBB", ")", ";", "MBB", ".", "addSuccessor", "(", "Sink", ")", ";", "assert", "(", "Sink", "->", "getParent", "(", ")", "==", "&", "MF", ")", ";", "after", "=", "BuildMI", "(", "MBB", ",", "++", "after", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "InstrInfo", "->", "get", "(", "Mips", "::", "BEQ64", ")", ")", ".", "addUse", "(", "tag_after", ",", "RegState", "::", "Kill", ")", ".", "addUse", "(", "tag_before", ",", "RegState", "::", "Kill", ")", ".", "addMBB", "(", "Sink", ")", ";", "BuildMI", "(", "MBB", ",", "++", "after", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "InstrInfo", "->", "get", "(", "Mips", "::", "TRAP", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "16", "Mips::CIncOffset", "Mips::CSetOffset", "Mips::GPR64RegClass", "Mips::GPR64RegClass", "Mips::CGetTag", "1", "Mips::CGetTag", "0", "Mips::BEQ64", "Mips::TRAP" ]

[]

[ "<s>", "int", "arm_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "(", "regno", "==", "CC_REGNUM", "||", "(", "TARGET_HARD_FLOAT", "&&", "regno", "==", "VFPCC_REGNUM", ")", ")", ";", "if", "(", "regno", "==", "CC_REGNUM", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "TARGET_THUMB1", ")", "return", "(", "ARM_NUM_REGS", "(", "mode", ")", "<", "2", ")", "||", "(", "regno", "<", "LAST_LO_REGNUM", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "DFmode", ")", "return", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "HFmode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "HImode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "TARGET_NEON", ")", "return", "(", "VALID_NEON_DREG_MODE", "(", "mode", ")", "&&", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ")", "||", "(", "VALID_NEON_QREG_MODE", "(", "mode", ")", "&&", "NEON_REGNO_OK_FOR_QUAD", "(", "regno", ")", ")", "||", "(", "mode", "==", "TImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "2", ")", ")", "||", "(", "mode", "==", "EImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "3", ")", ")", "||", "(", "mode", "==", "OImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "4", ")", ")", "||", "(", "mode", "==", "CImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "6", ")", ")", "||", "(", "mode", "==", "XImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "8", ")", ")", ";", "return", "FALSE", ";", "}", "if", "(", "TARGET_REALLY_IWMMXT", ")", "{", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ";", "}", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", ")", "{", "if", "(", "ARM_NUM_REGS", "(", "mode", ")", ">", "4", ")", "return", "FALSE", ";", "if", "(", "TARGET_THUMB2", ")", "return", "TRUE", ";", "return", "!", "(", "TARGET_LDRD", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "}", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Returns", "true", "if", "REGNO", "is", "a", "valid", "register", "for", "holding", "a", "quantity", "of", "type", "MODE", "." ]

[ "arm", "2", "2", "3", "4", "6", "8", "4", "4", "1", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "loongarch_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "exp", ")", "==", "CONSTRUCTOR", ")", "return", "MAX", "(", "align", ",", "BITS_PER_WORD", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", "." ]

[ "loongarch" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addFastRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "TargetPassConfig", "::", "addFastRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "m32c_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "int", "extra_flags", "=", "0", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "m32c_special_page_vector_p", "(", "decl", ")", ")", "extra_flags", "=", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ";", "if", "(", "extra_flags", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "extra_flags", ";", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

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

[]

[ "<s>", "static", "int", "sh_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "srcclass", ",", "reg_class_t", "dstclass", ")", "{", "if", "(", "dstclass", "==", "T_REGS", "||", "dstclass", "==", "PR_REGS", ")", "return", "10", ";", "if", "(", "dstclass", "==", "MAC_REGS", "&&", "srcclass", "==", "MAC_REGS", ")", "return", "4", ";", "if", "(", "mode", "==", "SImode", "&&", "TARGET_FMOVD", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", "&&", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", ")", "return", "4", ";", "if", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "srcclass", "==", "T_REGS", ")", "return", "(", "(", "TARGET_HARD_SH4", "&&", "!", "optimize_size", ")", "?", "10", ":", "7", ")", ";", "if", "(", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "srcclass", "==", "MAC_REGS", ")", "||", "(", "dstclass", "==", "MAC_REGS", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", ")", ")", "return", "9", ";", "if", "(", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", "||", "(", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", ")", ")", "{", "int", "addend", "=", "(", "mode", "==", "Pmode", ")", "?", "40", ":", "0", ";", "return", "(", "(", "TARGET_FMOVD", "?", "8", ":", "12", ")", "+", "addend", ")", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", "/", "8U", ")", ";", "}", "if", "(", "(", "dstclass", "==", "FPUL_REGS", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", "||", "(", "srcclass", "==", "FPUL_REGS", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", ")", "return", "5", ";", "if", "(", "(", "dstclass", "==", "FPUL_REGS", "&&", "(", "srcclass", "==", "PR_REGS", "||", "srcclass", "==", "MAC_REGS", "||", "srcclass", "==", "T_REGS", ")", ")", "||", "(", "srcclass", "==", "FPUL_REGS", "&&", "(", "dstclass", "==", "PR_REGS", "||", "dstclass", "==", "MAC_REGS", ")", ")", ")", "return", "7", ";", "if", "(", "(", "srcclass", "==", "FPSCR_REGS", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", "||", "(", "dstclass", "==", "FPSCR_REGS", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", ")", "return", "4", ";", "if", "(", "TARGET_FMOVD", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", "return", "2", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", "/", "8U", ")", ";", "return", "2", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4U", ")", ";", "}", "</s>" ]

[ "If", "SECONDARY", "*", "_RELOAD_CLASS", "says", "something", "about", "the", "src/dst", "pair", ",", "regclass", "uses", "this", "information", ".", "Hence", ",", "the", "general", "register", "<", "-", ">", "floating", "point", "register", "information", "here", "is", "not", "used", "for", "SFmode", "." ]

[ "sh", "10", "4", "4", "10", "7", "9", "40", "0", "8", "12", "7", "8U", "5", "7", "4", "2", "7", "8U", "2", "3", "4U" ]

[]

[ "<s>", "static", "machine_mode", "type_natural_mode", "(", "const_tree", "type", ",", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "bool", "in_return", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "(", "size", "==", "8", "||", "size", "==", "16", "||", "size", "==", "32", "||", "size", "==", "64", ")", "&&", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", ">", "1", ")", "{", "machine_mode", "innermode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "innermode", "==", "XFmode", ")", "return", "mode", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "innermode", ")", ")", "return", "mode", ";", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "REAL_TYPE", ")", "mode", "=", "MIN_MODE_VECTOR_FLOAT", ";", "else", "mode", "=", "MIN_MODE_VECTOR_INT", ";", "FOR_EACH_MODE_FROM", "(", "mode", ",", "mode", ")", "if", "(", "GET_MODE_NUNITS", "(", "mode", ")", "==", "TYPE_VECTOR_SUBPARTS", "(", "type", ")", "&&", "GET_MODE_INNER", "(", "mode", ")", "==", "innermode", ")", "{", "if", "(", "size", "==", "64", "&&", "!", "TARGET_AVX512F", "&&", "!", "TARGET_IAMCU", ")", "{", "static", "bool", "warnedavx512f", ";", "static", "bool", "warnedavx512f_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_avx512f", "&&", "!", "warnedavx512f", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX512F vector argument \"", "\"without AVX512F enabled changes the ABI\"", ")", ")", "warnedavx512f", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedavx512f_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX512F vector return \"", "\"without AVX512F enabled changes the ABI\"", ")", ")", "warnedavx512f_ret", "=", "true", ";", "}", "return", "TYPE_MODE", "(", "type", ")", ";", "}", "else", "if", "(", "size", "==", "32", "&&", "!", "TARGET_AVX", "&&", "!", "TARGET_IAMCU", ")", "{", "static", "bool", "warnedavx", ";", "static", "bool", "warnedavx_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_avx", "&&", "!", "warnedavx", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX vector argument \"", "\"without AVX enabled changes the ABI\"", ")", ")", "warnedavx", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedavx_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"AVX vector return \"", "\"without AVX enabled changes the ABI\"", ")", ")", "warnedavx_ret", "=", "true", ";", "}", "return", "TYPE_MODE", "(", "type", ")", ";", "}", "else", "if", "(", "(", "(", "size", "==", "8", "&&", "TARGET_64BIT", ")", "||", "size", "==", "16", ")", "&&", "!", "TARGET_SSE", "&&", "!", "TARGET_IAMCU", ")", "{", "static", "bool", "warnedsse", ";", "static", "bool", "warnedsse_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_sse", "&&", "!", "warnedsse", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"SSE vector argument \"", "\"without SSE enabled changes the ABI\"", ")", ")", "warnedsse", "=", "true", ";", "}", "else", "if", "(", "!", "TARGET_64BIT", "&&", "in_return", "&&", "!", "warnedsse_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"SSE vector return \"", "\"without SSE enabled changes the ABI\"", ")", ")", "warnedsse_ret", "=", "true", ";", "}", "}", "else", "if", "(", "(", "size", "==", "8", "&&", "!", "TARGET_64BIT", ")", "&&", "(", "!", "cfun", "||", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_NORMAL", ")", "&&", "!", "TARGET_MMX", "&&", "!", "TARGET_IAMCU", ")", "{", "static", "bool", "warnedmmx", ";", "static", "bool", "warnedmmx_ret", ";", "if", "(", "cum", "&&", "cum", "->", "warn_mmx", "&&", "!", "warnedmmx", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"MMX vector argument \"", "\"without MMX enabled changes the ABI\"", ")", ")", "warnedmmx", "=", "true", ";", "}", "else", "if", "(", "in_return", "&&", "!", "warnedmmx_ret", ")", "{", "if", "(", "warning", "(", "OPT_Wpsabi", ",", "\"MMX vector return \"", "\"without MMX enabled changes the ABI\"", ")", ")", "warnedmmx_ret", "=", "true", ";", "}", "}", "return", "mode", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "``", "natural", "''", "mode", "for", "TYPE", ".", "In", "most", "cases", ",", "this", "is", "just", "TYPE_MODE", ".", "But", "in", "the", "case", "of", "vector", "types", ",", "it", "is", "some", "vector", "mode", ".", "When", "we", "have", "only", "some", "of", "our", "vector", "isa", "extensions", "enabled", ",", "then", "there", "are", "some", "modes", "for", "which", "vector_mode_supported_p", "is", "false", ".", "For", "these", "modes", ",", "the", "generic", "vector", "support", "in", "gcc", "will", "choose", "some", "non-vector", "mode", "in", "order", "to", "implement", "the", "type", ".", "By", "computing", "the", "natural", "mode", ",", "we", "'ll", "select", "the", "proper", "ABI", "location", "for", "the", "operand", "and", "not", "depend", "on", "whatever", "the", "middle-end", "decides", "to", "do", "with", "these", "vector", "types", "." ]

[ "i386", "8", "16", "32", "64", "1", "64", "\"AVX512F vector argument \"", "\"without AVX512F enabled changes the ABI\"", "\"AVX512F vector return \"", "\"without AVX512F enabled changes the ABI\"", "32", "\"AVX vector argument \"", "\"without AVX enabled changes the ABI\"", "\"AVX vector return \"", "\"without AVX enabled changes the ABI\"", "8", "16", "\"SSE vector argument \"", "\"without SSE enabled changes the ABI\"", "\"SSE vector return \"", "\"without SSE enabled changes the ABI\"", "8", "\"MMX vector argument \"", "\"without MMX enabled changes the ABI\"", "\"MMX vector return \"", "\"without MMX enabled changes the ABI\"" ]

[]

[ "<s>", "static", "bool", "rs6000_const_not_ok_for_debug_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "{", "rtx", "c", "=", "get_pool_constant", "(", "x", ")", ";", "machine_mode", "cmode", "=", "get_pool_mode", "(", "x", ")", ";", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "c", ",", "cmode", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "should", "n't", "be", "emitted", "into", "the", "debug", "info", ".", "The", "linker", "does", "n't", "like", ".toc", "section", "references", "from", ".debug_", "*", "sections", ",", "so", "reject", ".toc", "section", "symbols", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", ",", "int", "caller", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "NULL", ";", "struct", "cgraph_node", "*", "target", "=", "NULL", ";", "memset", "(", "cum", ",", "0", ",", "sizeof", "(", "*", "cum", ")", ")", ";", "if", "(", "fndecl", ")", "{", "target", "=", "cgraph_node", "::", "get", "(", "fndecl", ")", ";", "if", "(", "target", ")", "{", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "i", "=", "cgraph_node", "::", "local_info", "(", "target", "->", "decl", ")", ";", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "target", "->", "decl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_abi", "(", "fndecl", ")", ";", "}", "else", "cum", "->", "call_abi", "=", "ix86_function_type_abi", "(", "fntype", ")", ";", "cum", "->", "caller", "=", "caller", ";", "cum", "->", "nregs", "=", "ix86_regparm", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "}", "if", "(", "TARGET_SSE", ")", "{", "cum", "->", "sse_nregs", "=", "SSE_REGPARM_MAX", ";", "if", "(", "TARGET_64BIT", ")", "{", "cum", "->", "sse_nregs", "=", "(", "cum", "->", "call_abi", "==", "SYSV_ABI", "?", "X86_64_SSE_REGPARM_MAX", ":", "X86_64_MS_SSE_REGPARM_MAX", ")", ";", "}", "}", "if", "(", "TARGET_MMX", ")", "cum", "->", "mmx_nregs", "=", "MMX_REGPARM_MAX", ";", "cum", "->", "warn_avx512f", "=", "true", ";", "cum", "->", "warn_avx", "=", "true", ";", "cum", "->", "warn_sse", "=", "true", ";", "cum", "->", "warn_mmx", "=", "true", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "fntype", "=", "TREE_TYPE", "(", "target", "->", "decl", ")", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "maybe_vaarg", "=", "(", "fntype", "?", "(", "!", "prototype_p", "(", "fntype", ")", "||", "stdarg_p", "(", "fntype", ")", ")", ":", "!", "libname", ")", ";", "cum", "->", "bnd_regno", "=", "FIRST_BND_REG", ";", "cum", "->", "bnds_in_bt", "=", "0", ";", "cum", "->", "force_bnd_pass", "=", "0", ";", "cum", "->", "decl", "=", "fndecl", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cfun", "->", "machine", "->", "arg_reg_available", "=", "true", ";", "cum", "->", "sse_nregs", "=", "0", ";", "cum", "->", "mmx_nregs", "=", "0", ";", "cum", "->", "warn_avx512f", "=", "false", ";", "cum", "->", "warn_avx", "=", "false", ";", "cum", "->", "warn_sse", "=", "false", ";", "cum", "->", "warn_mmx", "=", "false", ";", "return", ";", "}", "if", "(", "fntype", ")", "{", "unsigned", "int", "ccvt", "=", "ix86_get_callcvt", "(", "fntype", ")", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "{", "cum", "->", "nregs", "=", "1", ";", "cum", "->", "fastcall", "=", "1", ";", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "{", "cum", "->", "nregs", "=", "2", ";", "cum", "->", "fastcall", "=", "1", ";", "}", "else", "cum", "->", "nregs", "=", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", ";", "}", "cum", "->", "float_in_sse", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fndecl", ",", "true", ")", ";", "}", "cfun", "->", "machine", "->", "arg_reg_available", "=", "(", "cum", "->", "nregs", ">", "0", ")", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

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

[]

[ "<s>", "void", "ARMTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "MCInstrDesc", "*", "MCID", "=", "&", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "NewOpc", "=", "convertAddSubFlagsOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NewOpc", ")", "{", "const", "ARMBaseInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MCID", "=", "&", "TII", "->", "get", "(", "NewOpc", ")", ";", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "1", "&&", "\"converted opcode should be the same except for cc_out\"", ")", ";", "MI", "->", "setDesc", "(", "*", "MCID", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "0", ",", "true", ")", ")", ";", "}", "unsigned", "ccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "!", "MI", "->", "hasOptionalDef", "(", ")", "||", "!", "MCID", "->", "OpInfo", "[", "ccOutIdx", "]", ".", "isOptionalDef", "(", ")", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "bool", "definesCPSR", "=", "false", ";", "bool", "deadCPSR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "MCID", "->", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "{", "definesCPSR", "=", "true", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "deadCPSR", "=", "true", ";", "MI", "->", "RemoveOperand", "(", "i", ")", ";", "break", ";", "}", "}", "if", "(", "!", "definesCPSR", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "assert", "(", "deadCPSR", "==", "!", "Node", "->", "hasAnyUseOfValue", "(", "1", ")", "&&", "\"inconsistent dead flag\"", ")", ";", "if", "(", "deadCPSR", ")", "{", "assert", "(", "!", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ".", "getReg", "(", ")", "&&", "\"expect uninitialized optional cc_out operand\"", ")", ";", "return", ";", "}", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ";", "MO", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";", "MO", ".", "setIsDef", "(", "true", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "1", "\"converted opcode should be the same except for cc_out\"", "0", "1", "\"Optional cc_out operand required\"", "ARM::CPSR", "\"Optional cc_out operand required\"", "1", "\"inconsistent dead flag\"", "\"expect uninitialized optional cc_out operand\"", "ARM::CPSR" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "Sparc", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "bool", "SSACCmpConv", "::", "isDeadDef", "(", "unsigned", "DstReg", ")", "{", "if", "(", "DstReg", "==", "ARM64", "::", "WZR", "||", "DstReg", "==", "ARM64", "::", "XZR", ")", "return", "true", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "return", "false", ";", "return", "MRI", "->", "use_nodbg_empty", "(", "DstReg", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "a", "dead", "def", "." ]

[ "ARM64", "ARM64::WZR", "ARM64::XZR" ]

[]

[ "<s>", "static", "bool", "ix86_must_pass_in_stack", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "must_pass_in_stack_var_size_or_pad", "(", "mode", ",", "type", ")", ")", "return", "true", ";", "return", "(", "!", "TARGET_64BIT", "&&", "mode", "==", "TImode", "&&", "type", "&&", "TREE_CODE", "(", "type", ")", "!=", "VECTOR_TYPE", ")", ";", "}", "</s>" ]

[ "Return", "if", "we", "do", "not", "know", "how", "to", "pass", "TYPE", "solely", "in", "registers", "." ]

[ "i386" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "uint64_t", "TSFlags", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "if", "(", "RISCVII", "::", "hasSEWOp", "(", "TSFlags", ")", ")", "{", "unsigned", "NumOperands", "=", "MI", ".", "getNumExplicitOperands", "(", ")", ";", "int", "VLIndex", "=", "RISCVII", "::", "hasVLOp", "(", "TSFlags", ")", "?", "NumOperands", "-", "2", ":", "-", "1", ";", "unsigned", "SEWIndex", "=", "NumOperands", "-", "1", ";", "bool", "ForceTailAgnostic", "=", "RISCVII", "::", "doesForceTailAgnostic", "(", "TSFlags", ")", ";", "RISCVII", "::", "VLMUL", "VLMul", "=", "RISCVII", "::", "getLMul", "(", "TSFlags", ")", ";", "return", "addVSetVL", "(", "MI", ",", "BB", ",", "VLIndex", ",", "SEWIndex", ",", "VLMul", ",", "ForceTailAgnostic", ")", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR16_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVII::hasSEWOp", "RISCVII::hasVLOp", "2", "1", "1", "RISCVII::doesForceTailAgnostic", "RISCVII::VLMUL", "RISCVII::getLMul", "\"Unexpected instr type to insert\"", "RISCV::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR16_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "PerformMEMBARRIERCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "X86", "X86", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "ISD::SELECT", "X86ISD::CMOV", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::OR", "ISD::STORE", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::MEMBARRIER", "ISD::ZERO_EXTEND" ]

[]

[ "<s>", "static", "bool", "arc_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "arc_frame_pointer_needed", "(", ")", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "ARG_POINTER_REGNUM", "into", "FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "." ]

[ "arc" ]

[]

[ "<s>", "static", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "tree", "type", ";", "if", "(", "decl", ")", "{", "if", "(", "TARGET_ALTIVEC_VRSAVE", ")", "{", "for", "(", "type", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "type", ";", "type", "=", "TREE_CHAIN", "(", "type", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "type", ")", ")", "==", "VECTOR_TYPE", ")", "return", "false", ";", "}", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "||", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "rs6000", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "Cpu0SERegisterInfo", "::", "intRegClass", "(", "unsigned", "Size", ")", "const", "{", "return", "&", "Cpu0", "::", "CPURegsRegClass", ";", "}", "</s>" ]

[ "Return", "GPR", "register", "class", "." ]

[ "Cpu0", "Cpu0", "Cpu0::CPURegsRegClass" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "collect", "(", ")", "{", "ValueVect", "BO", ";", "getBlockTraversalOrder", "(", "&", "Fn", "->", "front", "(", ")", ",", "BO", ")", ";", "ValueToNodeMap", "NM", ";", "for", "(", "Value", "*", "I", ":", "BO", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "I", ")", ";", "for", "(", "Instruction", "&", "J", ":", "*", "B", ")", "if", "(", "auto", "*", "GepI", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "J", ")", ")", "if", "(", "isHandledGepForm", "(", "GepI", ")", ")", "processGepInst", "(", "GepI", ",", "NM", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Gep nodes after initial collection:\\n\"", "<<", "Nodes", ")", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "instruction", "MI", "and", "fill", "in", "the", "Uses", ",", "Defs", "and", "DeadDefs", "list", "based", "on", "the", "MachineOperand", "flags", "." ]

[ "Hexagon", "Hexagon", "\"Gep nodes after initial collection:\\n\"" ]

[]