Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "FramePtr", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "resetTargetOptions", "(", "F", ")", ";", "return", "getSubtargetImpl", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"target-cpu\"", "\"target-features\"" ]

[]

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

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

[ "Xtensa", "Xtensa::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "BTFTypeEnum", "::", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "if", "(", "IsCompleted", ")", "return", ";", "IsCompleted", "=", "true", ";", "BTFType", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "ETy", "->", "getName", "(", ")", ")", ";", "DINodeArray", "Elements", "=", "ETy", "->", "getElements", "(", ")", ";", "for", "(", "const", "auto", "Element", ":", "Elements", ")", "{", "const", "auto", "*", "Enum", "=", "cast", "<", "DIEnumerator", ">", "(", "Element", ")", ";", "struct", "BTF", "::", "BTFEnum", "BTFEnum", ";", "BTFEnum", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "Enum", "->", "getName", "(", ")", ")", ";", "BTFEnum", ".", "Val", "=", "static_cast", "<", "uint32_t", ">", "(", "Enum", "->", "getValue", "(", ")", ")", ";", "EnumValues", ".", "push_back", "(", "BTFEnum", ")", ";", "}", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF", "BTF::BTFEnum" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "static", "rtx", "dump_constants_1", "(", "enum", "machine_mode", "mode", ",", "rtx", "value", ",", "rtx", "insn", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_INT", ":", "{", "rtx", "size", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "return", "emit_insn_after", "(", "gen_consttable_int", "(", "value", ",", "size", ")", ",", "insn", ")", ";", "}", "case", "MODE_FLOAT", ":", "return", "emit_insn_after", "(", "gen_consttable_float", "(", "value", ")", ",", "insn", ")", ";", "case", "MODE_VECTOR_FLOAT", ":", "case", "MODE_VECTOR_INT", ":", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "value", ")", ";", "i", "++", ")", "insn", "=", "dump_constants_1", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "CONST_VECTOR_ELT", "(", "value", ",", "i", ")", ",", "insn", ")", ";", "return", "insn", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "constant", "VALUE", "after", "instruction", "INSN", "and", "return", "the", "last", "instruction", "emitted", ".", "MODE", "is", "the", "mode", "of", "the", "constant", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "override", "{", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_move", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "REG", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "if", "(", "REGNO", "(", "src", ")", "==", "CC_REG", ")", "return", "\"mvc\\t%0\"", ";", "else", "return", "\"mov\\t%0,%1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "LABEL_REF", ")", "return", "\"lrw\\t%0,[%1]\"", ";", "else", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "E_SImode", ":", "return", "\"ldw\\t%0,%1\"", ";", "case", "E_HImode", ":", "return", "\"ld.h\\t%0,%1\"", ";", "case", "E_QImode", ":", "return", "\"ld.b\\t%0,%1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "x", ",", "y", ";", "if", "(", "CONST_OK_FOR_I", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"movi\\t%0,%1\"", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"bgeni\\t%0,%P1\\t// %1 %x1\"", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"bmaski\\t%0,%N1\\t// %1 %x1\"", ";", "else", "if", "(", "try_constant_tricks", "(", "INTVAL", "(", "src", ")", ",", "&", "x", ",", "&", "y", ")", ")", "return", "output_inline_const", "(", "SImode", ",", "operands", ")", ";", "else", "return", "\"lrw\\t%0,%x1\\t// %1\"", ";", "}", "else", "return", "\"lrw\\t%0, %1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "E_SImode", ":", "return", "\"stw\\t%1,%0\"", ";", "case", "E_HImode", ":", "return", "\"st.h\\t%1,%0\"", ";", "case", "E_QImode", ":", "return", "\"st.b\\t%1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Output", "a", "move", "of", "a", "word", "or", "less", "value", "." ]

[ "mcore", "0", "1", "\"mvc\\t%0\"", "\"mov\\t%0,%1\"", "0", "\"lrw\\t%0,[%1]\"", "\"ldw\\t%0,%1\"", "\"ld.h\\t%0,%1\"", "\"ld.b\\t%0,%1\"", "\"movi\\t%0,%1\"", "\"bgeni\\t%0,%P1\\t// %1 %x1\"", "\"bmaski\\t%0,%N1\\t// %1 %x1\"", "\"lrw\\t%0,%x1\\t// %1\"", "\"lrw\\t%0, %1\"", "\"stw\\t%1,%0\"", "\"st.h\\t%1,%0\"", "\"st.b\\t%1,%0\"" ]

[]

[ "<s>", "static", "int", "access_check", "(", "const", "char", "*", "name", ",", "int", "mode", ")", "{", "if", "(", "mode", "==", "X_OK", ")", "{", "struct", "stat", "st", ";", "if", "(", "stat", "(", "name", ",", "&", "st", ")", "<", "0", "||", "S_ISDIR", "(", "st", ".", "st_mode", ")", ")", "return", "-", "1", ";", "}", "return", "access", "(", "name", ",", "mode", ")", ";", "}", "</s>" ]

[ "Check", "whether", "NAME", "can", "be", "accessed", "in", "MODE", ".", "This", "is", "like", "access", ",", "except", "that", "it", "never", "considers", "directories", "to", "be", "executable", "." ]

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

[]

[ "<s>", "static", "void", "pa_hpux_file_end", "(", "void", ")", "{", "unsigned", "int", "i", ";", "extern_symbol", "*", "p", ";", "if", "(", "!", "NO_DEFERRED_PROFILE_COUNTERS", ")", "output_deferred_profile_counters", "(", ")", ";", "output_deferred_plabels", "(", ")", ";", "for", "(", "i", "=", "0", ";", "VEC_iterate", "(", "extern_symbol", ",", "extern_symbols", ",", "i", ",", "p", ")", ";", "i", "++", ")", "{", "tree", "decl", "=", "p", "->", "decl", ";", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", "&&", "SYMBOL_REF_REFERENCED_P", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ")", ")", "ASM_OUTPUT_EXTERNAL_REAL", "(", "asm_out_file", ",", "decl", ",", "p", "->", "name", ")", ";", "}", "VEC_free", "(", "extern_symbol", ",", "gc", ",", "extern_symbols", ")", ";", "}", "</s>" ]

[ "Output", "text", "required", "at", "the", "end", "of", "an", "assembler", "file", ".", "This", "includes", "deferred", "plabels", "and", ".import", "directives", "for", "all", "external", "symbols", "that", "were", "actually", "referenced", "." ]

[ "pa", "0", "0" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "llvm_unreachable", "(", "\"unimplemented!\"", ")", ";", "}", "</s>" ]

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

[ "FISC", "\"unimplemented!\"" ]

[]

[ "<s>", "static", "void", "c6x_reorg", "(", "void", ")", "{", "basic_block", "bb", ";", "bool", "do_selsched", "=", "(", "c6x_flag_schedule_insns2", "&&", "flag_selective_scheduling2", "&&", "!", "maybe_skip_selective_scheduling", "(", ")", ")", ";", "compute_bb_for_insn", "(", ")", ";", "df_clear_flags", "(", "DF_LR_RUN_DCE", ")", ";", "df_note_add_problem", "(", ")", ";", "if", "(", "optimize", "==", "0", ")", "split_all_insns", "(", ")", ";", "df_analyze", "(", ")", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "int", "sz", "=", "get_max_uid", "(", ")", "*", "3", "/", "2", "+", "1", ";", "insn_info", ".", "create", "(", "sz", ")", ";", "}", "sched_no_dce", "=", "true", ";", "c6x_hwloops", "(", ")", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "split_delayed_insns", "(", ")", ";", "timevar_push", "(", "TV_SCHED2", ")", ";", "if", "(", "do_selsched", ")", "run_selective_scheduling", "(", ")", ";", "else", "schedule_ebbs", "(", ")", ";", "conditionalize_after_sched", "(", ")", ";", "timevar_pop", "(", "TV_SCHED2", ")", ";", "free_delay_pairs", "(", ")", ";", "}", "sched_no_dce", "=", "false", ";", "rtx_code_label", "*", "*", "call_labels", "=", "XCNEWVEC", "(", "rtx_code_label", "*", ",", "get_max_uid", "(", ")", "+", "1", ")", ";", "reorg_split_calls", "(", "call_labels", ")", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "if", "(", "(", "bb", "->", "flags", "&", "BB_DISABLE_SCHEDULE", ")", "==", "0", ")", "assign_reservations", "(", "BB_HEAD", "(", "bb", ")", ",", "BB_END", "(", "bb", ")", ")", ";", "}", "if", "(", "c6x_flag_var_tracking", ")", "{", "timevar_push", "(", "TV_VAR_TRACKING", ")", ";", "variable_tracking_main", "(", ")", ";", "timevar_pop", "(", "TV_VAR_TRACKING", ")", ";", "}", "reorg_emit_nops", "(", "call_labels", ")", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "free_delay_pairs", "(", ")", ";", "c6x_gen_bundles", "(", ")", ";", "}", "df_finish_pass", "(", "false", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_MACHINE_DEPENDENT_REORG", "pass", ".", "We", "split", "call", "insns", "here", "into", "a", "sequence", "that", "loads", "the", "return", "register", "and", "performs", "the", "call", ",", "and", "emit", "the", "return", "label", ".", "If", "scheduling", "after", "reload", "is", "requested", ",", "it", "happens", "here", "." ]

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

[]

[ "<s>", "void", "AArch64ConditionOptimizer", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "int", "ix86_min_insn_size", "(", "rtx_insn", "*", "insn", ")", "{", "int", "l", "=", "0", ",", "len", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "!", "active_insn_p", "(", "insn", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "if", "(", "CALL_P", "(", "insn", ")", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", "&&", "!", "SIBLING_CALL_P", "(", "insn", ")", ")", "return", "5", ";", "len", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "len", "<=", "1", ")", "return", "1", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "switch", "(", "type", ")", "{", "case", "TYPE_MULTI", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", "return", "0", ";", "break", ";", "case", "TYPE_OTHER", ":", "case", "TYPE_FCMP", ":", "break", ";", "default", ":", "return", "len", ";", "}", "l", "=", "get_attr_length_address", "(", "insn", ")", ";", "if", "(", "l", "<", "4", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "l", "=", "4", ";", "}", "if", "(", "l", ")", "return", "1", "+", "l", ";", "else", "return", "2", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ix86_test_loading_dump_fragment_1", "(", ")", "{", "rtl_dump_test", "t", "(", "SELFTEST_LOCATION", ",", "locate_file", "(", "\"x86_64/copy-hard-reg-into-frame.rtl\"", ")", ")", ";", "rtx_insn", "*", "insn", "=", "get_insn_by_uid", "(", "1", ")", ";", "tree", "mem_expr", ";", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "ASSERT_EQ", "(", "SET", ",", "GET_CODE", "(", "pat", ")", ")", ";", "{", "rtx", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "ASSERT_EQ", "(", "MEM", ",", "GET_CODE", "(", "dest", ")", ")", ";", "ASSERT_TRUE", "(", "RTX_FLAG", "(", "dest", ",", "call", ")", ")", ";", "ASSERT_EQ", "(", "SImode", ",", "GET_MODE", "(", "dest", ")", ")", ";", "{", "rtx", "addr", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "ASSERT_EQ", "(", "PLUS", ",", "GET_CODE", "(", "addr", ")", ")", ";", "ASSERT_EQ", "(", "DImode", ",", "GET_MODE", "(", "addr", ")", ")", ";", "{", "rtx", "lhs", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "ASSERT_RTX_PTR_EQ", "(", "frame_pointer_rtx", ",", "lhs", ")", ";", "}", "{", "rtx", "rhs", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "ASSERT_EQ", "(", "CONST_INT", ",", "GET_CODE", "(", "rhs", ")", ")", ";", "ASSERT_EQ", "(", "-", "4", ",", "INTVAL", "(", "rhs", ")", ")", ";", "}", "}", "ASSERT_EQ", "(", "1", ",", "MEM_ALIAS_SET", "(", "dest", ")", ")", ";", "mem_expr", "=", "MEM_EXPR", "(", "dest", ")", ";", "ASSERT_NE", "(", "mem_expr", ",", "NULL", ")", ";", "ASSERT_EQ", "(", "VAR_DECL", ",", "TREE_CODE", "(", "mem_expr", ")", ")", ";", "ASSERT_EQ", "(", "integer_type_node", ",", "TREE_TYPE", "(", "mem_expr", ")", ")", ";", "ASSERT_EQ", "(", "IDENTIFIER_NODE", ",", "TREE_CODE", "(", "DECL_NAME", "(", "mem_expr", ")", ")", ")", ";", "ASSERT_STREQ", "(", "\"i\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "mem_expr", ")", ")", ")", ";", "ASSERT_TRUE", "(", "MEM_OFFSET_KNOWN_P", "(", "dest", ")", ")", ";", "ASSERT_EQ", "(", "0", ",", "MEM_OFFSET", "(", "dest", ")", ")", ";", "ASSERT_EQ", "(", "4", ",", "MEM_SIZE", "(", "dest", ")", ")", ";", "ASSERT_EQ", "(", "32", ",", "MEM_ALIGN", "(", "dest", ")", ")", ";", "}", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "ASSERT_EQ", "(", "REG", ",", "GET_CODE", "(", "src", ")", ")", ";", "ASSERT_EQ", "(", "SImode", ",", "GET_MODE", "(", "src", ")", ")", ";", "ASSERT_EQ", "(", "5", ",", "REGNO", "(", "src", ")", ")", ";", "tree", "reg_expr", "=", "REG_EXPR", "(", "src", ")", ";", "ASSERT_EQ", "(", "reg_expr", ",", "mem_expr", ")", ";", "}", "}", "}", "</s>" ]

[ "Verify", "loading", "an", "RTL", "dump", ";", "specifically", "a", "dump", "of", "copying", "a", "param", "on", "x86_64", "from", "a", "hard", "reg", "into", "the", "frame", ".", "This", "test", "is", "target-specific", "since", "the", "dump", "contains", "target-specific", "hard", "reg", "names", "." ]

[ "i386", "\"x86_64/copy-hard-reg-into-frame.rtl\"", "1", "0", "0", "1", "4", "1", "\"i\"", "0", "4", "32", "5" ]

[]

[ "<s>", "int", "s390_mem_constraint", "(", "const", "char", "*", "str", ",", "rtx", "op", ")", "{", "char", "c", "=", "str", "[", "0", "]", ";", "switch", "(", "c", ")", "{", "case", "'A'", ":", "if", "(", "!", "MEM_P", "(", "op", ")", "||", "MEM_VOLATILE_P", "(", "op", ")", ")", "return", "0", ";", "if", "(", "(", "reload_completed", "||", "reload_in_progress", ")", "?", "!", "offsettable_memref_p", "(", "op", ")", ":", "!", "offsettable_nonstrict_memref_p", "(", "op", ")", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "XEXP", "(", "op", ",", "0", ")", ",", "true", ")", ";", "case", "'B'", ":", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "XEXP", "(", "op", ",", "0", ")", ",", "false", ")", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "return", "s390_check_qrst_address", "(", "c", ",", "XEXP", "(", "op", ",", "0", ")", ",", "true", ")", ";", "case", "'U'", ":", "return", "(", "s390_check_qrst_address", "(", "'Q'", ",", "op", ",", "true", ")", "||", "s390_check_qrst_address", "(", "'R'", ",", "op", ",", "true", ")", ")", ";", "case", "'W'", ":", "return", "(", "s390_check_qrst_address", "(", "'S'", ",", "op", ",", "true", ")", "||", "s390_check_qrst_address", "(", "'T'", ",", "op", ",", "true", ")", ")", ";", "case", "'Y'", ":", "if", "(", "!", "s390_decompose_shift_count", "(", "op", ",", "NULL", ",", "NULL", ")", ")", "return", "0", ";", "break", ";", "case", "'Z'", ":", "return", "s390_check_qrst_address", "(", "str", "[", "1", "]", ",", "op", ",", "true", ")", ";", "default", ":", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Evaluates", "constraint", "strings", "described", "by", "the", "regular", "expression", "(", "[", "A|B|Z", "]", "(", "Q|R|S|T", ")", ")", "|U|W|Y", "and", "returns", "1", "if", "OP", "is", "a", "valid", "operand", "for", "the", "constraint", "given", "in", "STR", ",", "or", "0", "else", "." ]

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

[]

[ "<s>", "static", "const", "char", "*", "get_some_local_dynamic_name", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "get_some_local_dynamic_name_1", ",", "0", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Locate", "some", "local-dynamic", "symbol", "still", "in", "use", "by", "this", "function", "so", "that", "we", "can", "print", "its", "name", "in", "local-dynamic", "base", "patterns", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "static", "int", "aarch64_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "auto", "check_attr", "=", "[", "&", "]", "(", "const", "char", "*", "name", ")", "{", "tree", "attr1", "=", "lookup_attribute", "(", "name", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", ";", "tree", "attr2", "=", "lookup_attribute", "(", "name", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ";", "if", "(", "!", "attr1", "&&", "!", "attr2", ")", "return", "true", ";", "return", "attr1", "&&", "attr2", "&&", "attribute_value_equal", "(", "attr1", ",", "attr2", ")", ";", "}", ";", "if", "(", "!", "check_attr", "(", "\"aarch64_vector_pcs\"", ")", ")", "return", "0", ";", "if", "(", "!", "check_attr", "(", "\"Advanced SIMD type\"", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_COMP_TYPE_ATTRIBUTES" ]

[ "aarch64", "\"aarch64_vector_pcs\"", "0", "\"Advanced SIMD type\"", "0", "1" ]

[]

[ "<s>", "bool", "MOSLowerSelect", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\\nHandling G_SELECTs in: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "moveAwayFromCalls", "(", "MF", ")", ";", "sinkSelectsToBranchUses", "(", "MF", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "I", "=", "MF", ".", "rbegin", "(", ")", ",", "E", "=", "MF", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "for", "(", "MachineInstr", "&", "MBBI", ":", "mbb_reverse", "(", "*", "I", ")", ")", "{", "if", "(", "MBBI", ".", "getOpcode", "(", ")", "==", "MOS", "::", "G_SELECT", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Lowering: \"", "<<", "MBBI", ")", ";", "Changed", "=", "true", ";", "I", "=", "lowerSelect", "(", "MBBI", ")", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "\"\\n\\nHandling G_SELECTs in: \"", "\"\\n\\n\"", "MOS::G_SELECT", "\"Lowering: \"" ]

[]

[ "<s>", "rtx", "rs6000_address_for_fpconvert", "(", "rtx", "x", ")", "{", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "rtx", "addr", ";", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "HOST_WIDE_INT", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "rtx", "size_rtx", "=", "GEN_INT", "(", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "?", "-", "size", ":", "size", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "reg", ",", "size_rtx", ")", ")", ";", "addr", "=", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "expr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "expr", ")", "==", "PLUS", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "XEXP", "(", "expr", ",", "0", ")", ",", "XEXP", "(", "expr", ",", "1", ")", ")", ")", ";", "addr", "=", "reg", ";", "}", "x", "=", "replace_equiv_address", "(", "x", ",", "copy_addr_to_reg", "(", "addr", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Given", "a", "memory", "reference", ",", "if", "it", "is", "not", "a", "reg", "or", "reg+reg", "addressing", ",", "convert", "to", "such", "a", "form", "to", "deal", "with", "memory", "reference", "instructions", "like", "STFIWX", "that", "only", "take", "reg+reg", "addressing", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "first", "&&", "MEM_P", "(", "rtl", ")", ")", "{", "nvptx_data_area", "area", "=", "DATA_AREA_GENERIC", ";", "if", "(", "TREE_CONSTANT", "(", "decl", ")", ")", "area", "=", "DATA_AREA_CONST", ";", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "if", "(", "lookup_attribute", "(", "\"shared\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "area", "=", "DATA_AREA_SHARED", ";", "if", "(", "DECL_INITIAL", "(", "decl", ")", ")", "error", "(", "\"static initialization of variable %q+D in %<.shared%>\"", "\" memory is not supported\"", ",", "decl", ")", ";", "}", "else", "area", "=", "TREE_READONLY", "(", "decl", ")", "?", "DATA_AREA_CONST", ":", "DATA_AREA_GLOBAL", ";", "}", "SET_SYMBOL_DATA_AREA", "(", "XEXP", "(", "rtl", ",", "0", ")", ",", "area", ")", ";", "}", "}", "</s>" ]

[ "Encode", "the", "PTX", "data", "area", "that", "DECL", "(", "which", "might", "not", "actually", "be", "a", "_DECL", ")", "should", "reside", "in", "." ]

[ "nvptx", "\"shared\"", "\"static initialization of variable %q+D in %<.shared%>\"", "\" memory is not supported\"", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIb", ")", ")", "return", "true", ";", "unsigned", "BasePosA", ",", "OffsetPosA", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIa", ",", "BasePosA", ",", "OffsetPosA", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseA", "=", "MIa", ".", "getOperand", "(", "BasePosA", ")", ";", "unsigned", "BaseRegA", "=", "BaseA", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubA", "=", "BaseA", ".", "getSubReg", "(", ")", ";", "unsigned", "BasePosB", ",", "OffsetPosB", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIb", ",", "BasePosB", ",", "OffsetPosB", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseB", "=", "MIb", ".", "getOperand", "(", "BasePosB", ")", ";", "unsigned", "BaseRegB", "=", "BaseB", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubB", "=", "BaseB", ".", "getSubReg", "(", ")", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", "||", "BaseSubA", "!=", "BaseSubB", ")", "return", "false", ";", "unsigned", "SizeA", "=", "(", "1u", "<<", "(", "getMemAccessSize", "(", "MIa", ")", "-", "1", ")", ")", ";", "unsigned", "SizeB", "=", "(", "1u", "<<", "(", "getMemAccessSize", "(", "MIb", ")", "-", "1", ")", ")", ";", "const", "MachineOperand", "&", "OffA", "=", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ";", "const", "MachineOperand", "&", "OffB", "=", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ";", "if", "(", "!", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ".", "isImm", "(", ")", "||", "!", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "int", "OffsetA", "=", "isPostIncrement", "(", "MIa", ")", "?", "0", ":", "OffA", ".", "getImm", "(", ")", ";", "int", "OffsetB", "=", "isPostIncrement", "(", "MIb", ")", "?", "0", ":", "OffB", ".", "getImm", "(", ")", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "SizeB", "<=", "OffDiff", ";", "}", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "SizeA", "<=", "OffDiff", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Hexagon", "Hexagon", "1u", "1", "1u", "1", "0", "0" ]

[]

[ "<s>", "bool", "mips_use_ins_ext_p", "(", "rtx", "op", ",", "HOST_WIDE_INT", "width", ",", "HOST_WIDE_INT", "bitpos", ")", "{", "if", "(", "!", "ISA_HAS_EXT_INS", "||", "!", "register_operand", "(", "op", ",", "VOIDmode", ")", "||", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ">", "BITS_PER_WORD", ")", "return", "false", ";", "if", "(", "!", "IN_RANGE", "(", "width", ",", "1", ",", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "-", "1", ")", ")", "return", "false", ";", "if", "(", "bitpos", "<", "0", "||", "bitpos", "+", "width", ">", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "(", "zero_extract", "OP", "SIZE", "POSITION", ")", "can", "be", "used", "as", "the", "source", "of", "an", "``", "ext", "''", "instruction", "or", "the", "destination", "of", "an", "``", "ins", "''", "instruction", ".", "OP", "must", "be", "a", "register", "operand", "and", "the", "following", "conditions", "must", "hold", ":", "0", "<", "=", "POSITION", "<", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "0", "<", "SIZE", "<", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "0", "<", "POSITION", "+", "SIZE", "<", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "Also", "reject", "lengths", "equal", "to", "a", "word", "as", "they", "are", "better", "handled", "by", "the", "move", "patterns", "." ]

[ "mips", "1", "1", "0" ]

[]

[ "<s>", "BitVector", "VERegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "Register", "ReservedRegs", "[", "]", "=", "{", "VE", "::", "SX8", ",", "VE", "::", "SX9", ",", "VE", "::", "SX10", ",", "VE", "::", "SX11", ",", "VE", "::", "SX12", ",", "VE", "::", "SX13", ",", "VE", "::", "SX14", ",", "VE", "::", "SX15", ",", "VE", "::", "SX16", ",", "VE", "::", "SX17", ",", "}", ";", "for", "(", "auto", "R", ":", "ReservedRegs", ")", "for", "(", "MCRegAliasIterator", "ItAlias", "(", "R", ",", "this", ",", "true", ")", ";", "ItAlias", ".", "isValid", "(", ")", ";", "++", "ItAlias", ")", "Reserved", ".", "set", "(", "*", "ItAlias", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::SX8", "VE::SX9", "VE::SX10", "VE::SX11", "VE::SX12", "VE::SX13", "VE::SX14", "VE::SX15", "VE::SX16", "VE::SX17" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ",", "bool", "&", "UseOneConst", ",", "bool", "Reciprocal", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", "||", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", "&&", "Subtarget", "->", "useRSqrt", "(", ")", ")", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRSQRTE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setUnsafeAlgebra", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Estimate", ",", "Flags", ")", ";", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRSQRTS", ",", "DL", ",", "VT", ",", "Operand", ",", "Step", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "Flags", ")", ";", "}", "if", "(", "!", "Reciprocal", ")", "{", "EVT", "CCVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "FPZero", "=", "DAG", ".", "getConstantFP", "(", "0.0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Eq", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "CCVT", ",", "Operand", ",", "FPZero", ",", "ISD", "::", "SETEQ", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "VT", ".", "isVector", "(", ")", "?", "ISD", "::", "VSELECT", ":", "ISD", "::", "SELECT", ",", "DL", ",", "VT", ",", "Eq", ",", "Operand", ",", "Estimate", ")", ";", "}", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "AArch64", "AArch64", "AArch64ISD::FRSQRTE", "0", "ISD::FMUL", "AArch64ISD::FRSQRTS", "ISD::FMUL", "0.0", "ISD::SETEQ", "ISD::FMUL", "ISD::VSELECT", "ISD::SELECT", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"LM32 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "LM32", "\"LM32 Assembly Printer\"" ]

[]

[ "<s>", "static", "rtx", "frv_int_to_acc", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ")", "{", "rtx", "reg", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "ACC_MASK", ";", "i", "++", ")", "if", "(", "(", "i", "&", "ACC_MASK", ")", "==", "i", ")", "global_regs", "[", "i", "+", "ACC_FIRST", "]", "=", "global_regs", "[", "i", "+", "ACCG_FIRST", "]", "=", "1", ";", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"accumulator is not a constant integer\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "(", "INTVAL", "(", "opval", ")", "&", "~", "ACC_MASK", ")", "!=", "0", ")", "{", "error", "(", "\"accumulator number is out of bounds\"", ")", ";", "return", "NULL_RTX", ";", "}", "reg", "=", "gen_rtx_REG", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "mode", ",", "ACC_FIRST", "+", "INTVAL", "(", "opval", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "reg", ",", "VOIDmode", ")", ")", "REGNO", "(", "reg", ")", "=", "ACCG_FIRST", "+", "INTVAL", "(", "opval", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "reg", ",", "VOIDmode", ")", ")", "{", "error", "(", "\"inappropriate accumulator for %qs\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "NULL_RTX", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Convert", "an", "integer", "constant", "to", "an", "accumulator", "register", ".", "ICODE", "is", "the", "code", "of", "the", "target", "instruction", ",", "OPNUM", "is", "the", "number", "of", "the", "accumulator", "operand", "and", "OPVAL", "is", "the", "constant", "integer", ".", "Try", "both", "ACC", "and", "ACCG", "registers", ";", "only", "report", "an", "error", "if", "neither", "fit", "the", "instruction", "." ]

[ "frv", "0", "1", "\"accumulator is not a constant integer\"", "0", "\"accumulator number is out of bounds\"", "\"inappropriate accumulator for %qs\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "orderFrameObjects", "(", "const", "MachineFunction", "&", "MF", ",", "SmallVectorImpl", "<", "int", ">", "&", "ObjectsToAllocate", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "ObjectsToAllocate", ".", "empty", "(", ")", ")", "return", ";", "std", "::", "vector", "<", "X86FrameSortingObject", ">", "SortingObjects", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ")", ";", "for", "(", "auto", "&", "Obj", ":", "ObjectsToAllocate", ")", "{", "SortingObjects", "[", "Obj", "]", ".", "IsValid", "=", "true", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectIndex", "=", "Obj", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectAlignment", "=", "MFI", ".", "getObjectAlignment", "(", "Obj", ")", ";", "int", "ObjectSize", "=", "MFI", ".", "getObjectSize", "(", "Obj", ")", ";", "if", "(", "ObjectSize", "==", "0", ")", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "4", ";", "else", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "ObjectSize", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isFI", "(", ")", ")", "continue", ";", "int", "Index", "=", "MO", ".", "getIndex", "(", ")", ";", "if", "(", "Index", ">=", "0", "&&", "Index", "<", "MFI", ".", "getObjectIndexEnd", "(", ")", "&&", "SortingObjects", "[", "Index", "]", ".", "IsValid", ")", "SortingObjects", "[", "Index", "]", ".", "ObjectNumUses", "++", ";", "}", "}", "}", "llvm", "::", "stable_sort", "(", "SortingObjects", ",", "X86FrameSortingComparator", "(", ")", ")", ";", "int", "i", "=", "0", ";", "for", "(", "auto", "&", "Obj", ":", "SortingObjects", ")", "{", "if", "(", "!", "Obj", ".", "IsValid", ")", "break", ";", "ObjectsToAllocate", "[", "i", "++", "]", "=", "Obj", ".", "ObjectIndex", ";", "}", "if", "(", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "hasFP", "(", "MF", ")", ")", "std", "::", "reverse", "(", "ObjectsToAllocate", ".", "begin", "(", ")", ",", "ObjectsToAllocate", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Order", "the", "symbols", "in", "the", "local", "stack", "." ]

[ "X86", "X86", "X86", "0", "4", "0", "X86", "0" ]

[]

[ "<s>", "const", "char", "*", "nds32_output_float_load", "(", "rtx", "*", "operands", ")", "{", "char", "buff", "[", "100", "]", ";", "const", "char", "*", "pattern", ";", "rtx", "addr", ",", "addr_op0", ",", "addr_op1", ";", "int", "dp", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "==", "8", ";", "addr", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "pattern", "=", "\"fl%ci\\t%%0, %%1\"", ";", "break", ";", "case", "PLUS", ":", "addr_op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr_op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "REG_P", "(", "addr_op0", ")", "&&", "REG_P", "(", "addr_op1", ")", ")", "pattern", "=", "\"fl%c\\t%%0, %%1\"", ";", "else", "if", "(", "REG_P", "(", "addr_op0", ")", "&&", "CONST_INT_P", "(", "addr_op1", ")", ")", "pattern", "=", "\"fl%ci\\t%%0, %%1\"", ";", "else", "if", "(", "GET_CODE", "(", "addr_op0", ")", "==", "MULT", "&&", "REG_P", "(", "addr_op1", ")", "&&", "REG_P", "(", "XEXP", "(", "addr_op0", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr_op0", ",", "1", ")", ")", ")", "pattern", "=", "\"fl%c\\t%%0, %%1\"", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "addr_op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr_op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "REG_P", "(", "addr_op0", ")", "&&", "GET_CODE", "(", "addr_op1", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr_op1", ",", "1", ")", ")", ")", "pattern", "=", "\"fl%c.bi\\t%%0, %%1\"", ";", "else", "if", "(", "REG_P", "(", "addr_op0", ")", "&&", "GET_CODE", "(", "addr_op1", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr_op1", ",", "1", ")", ")", ")", "pattern", "=", "\"fl%ci.bi\\t%%0, %%1\"", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "POST_INC", ":", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "{", "if", "(", "dp", ")", "pattern", "=", "\"fl%ci.bi\\t%%0, %%1, 8\"", ";", "else", "pattern", "=", "\"fl%ci.bi\\t%%0, %%1, 4\"", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "POST_DEC", ":", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "{", "if", "(", "dp", ")", "pattern", "=", "\"fl%ci.bi\\t%%0, %%1, -8\"", ";", "else", "pattern", "=", "\"fl%ci.bi\\t%%0, %%1, -4\"", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sprintf", "(", "buff", ",", "pattern", ",", "dp", "?", "'d'", ":", "'s'", ")", ";", "output_asm_insn", "(", "buff", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "output", "a", "float", "load", "instruction" ]

[ "nds32", "100", "0", "8", "1", "0", "\"fl%ci\\t%%0, %%1\"", "0", "1", "\"fl%c\\t%%0, %%1\"", "\"fl%ci\\t%%0, %%1\"", "0", "1", "\"fl%c\\t%%0, %%1\"", "0", "1", "1", "\"fl%c.bi\\t%%0, %%1\"", "1", "\"fl%ci.bi\\t%%0, %%1\"", "0", "\"fl%ci.bi\\t%%0, %%1, 8\"", "\"fl%ci.bi\\t%%0, %%1, 4\"", "0", "\"fl%ci.bi\\t%%0, %%1, -8\"", "\"fl%ci.bi\\t%%0, %%1, -4\"", "\"\"" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "Triple", "(", "TT", ")", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "Triple", "(", "getTargetTriple", "(", ")", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetSubtargetInfo", "*", "Z80TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "function", ")", "const", "{", "return", "&", "DefaultSubtarget", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "MCInst", "const", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "*", "MI", ")", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "HasExtender", "=", "false", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MI", ")", ")", "{", "MCInst", "const", "&", "MCI", "=", "*", "I", ".", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "MII", ",", "MCI", ")", ")", "{", "printInstruction", "(", "MCI", ".", "getOperand", "(", "1", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "OS", "<<", "'\\v'", ";", "HasExtender", "=", "false", ";", "printInstruction", "(", "MCI", ".", "getOperand", "(", "0", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "}", "else", "printInstruction", "(", "&", "MCI", ",", "OS", ")", ";", "setExtender", "(", "MCI", ")", ";", "OS", "<<", "\"\\n\"", ";", "}", "auto", "Separator", "=", "\"\"", ";", "if", "(", "HexagonMCInstrInfo", "::", "isInnerLoop", "(", "*", "MI", ")", ")", "{", "OS", "<<", "Separator", ";", "Separator", "=", "\" \"", ";", "MCInst", "ME", ";", "ME", ".", "setOpcode", "(", "Hexagon", "::", "ENDLOOP0", ")", ";", "printInstruction", "(", "&", "ME", ",", "OS", ")", ";", "}", "if", "(", "HexagonMCInstrInfo", "::", "isOuterLoop", "(", "*", "MI", ")", ")", "{", "OS", "<<", "Separator", ";", "Separator", "=", "\" \"", ";", "MCInst", "ME", ";", "ME", ".", "setOpcode", "(", "Hexagon", "::", "ENDLOOP1", ")", ";", "printInstruction", "(", "&", "ME", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "0", "\"\\n\"", "\"\"", "Hexagon", "\" \"", "Hexagon::ENDLOOP0", "Hexagon", "\" \"", "Hexagon::ENDLOOP1" ]

[]

[ "<s>", "void", "s390_expand_vec_compare_cc", "(", "rtx", "target", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp1", ",", "rtx", "cmp2", ",", "bool", "all_p", ")", "{", "machine_mode", "cc_producer_mode", ",", "cc_consumer_mode", ",", "scratch_mode", ";", "rtx", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "bool", "swap_p", "=", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp1", ")", ")", "==", "MODE_VECTOR_INT", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "break", ";", "case", "GE", ":", "case", "LT", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "swap_p", "=", "true", ";", "case", "GT", ":", "case", "LE", ":", "cc_producer_mode", "=", "CCVIHmode", ";", "break", ";", "case", "GEU", ":", "case", "LTU", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "swap_p", "=", "true", ";", "case", "GTU", ":", "case", "LEU", ":", "cc_producer_mode", "=", "CCVIHUmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "GET_MODE", "(", "cmp1", ")", ";", "if", "(", "code", "==", "NE", "||", "code", "==", "LE", "||", "code", "==", "LEU", ")", "all_p", "=", "!", "all_p", ";", "cc_consumer_mode", "=", "all_p", "?", "CCVIALLmode", ":", "CCVIANYmode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp1", ")", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "bool", "inv_p", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "break", ";", "case", "NE", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "GT", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "break", ";", "case", "GE", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "UNLE", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "UNLT", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "code", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "code", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "related_int_vector_mode", "(", "GET_MODE", "(", "cmp1", ")", ")", ".", "require", "(", ")", ";", "if", "(", "inv_p", ")", "all_p", "=", "!", "all_p", ";", "cc_consumer_mode", "=", "all_p", "?", "CCVFALLmode", ":", "CCVFANYmode", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "swap_p", ")", "{", "rtx", "tmp", "=", "cmp2", ";", "cmp2", "=", "cmp1", ";", "cmp1", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "cc_producer_mode", ",", "CC_REGNUM", ")", ",", "gen_rtx_COMPARE", "(", "cc_producer_mode", ",", "cmp1", ",", "cmp2", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "scratch_mode", ")", ")", ")", ")", ")", ";", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "const1_rtx", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "cc_consumer_mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ",", "tmp_reg", ",", "target", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "comparison", "CODE", "of", "CMP1", "and", "CMP2", "and", "copy", "1", "or", "0", "into", "TARGET", "if", "either", "all", "(", "ALL_P", "is", "true", ")", "or", "any", "(", "ALL_P", "is", "false", ")", "of", "the", "elements", "in", "CMP1", "and", "CMP2", "fulfill", "the", "comparison", "." ]

[ "s390", "2" ]

[]

[ "<s>", "static", "rtx", "pru_expand_delay_cycles", "(", "rtx", "arg", ")", "{", "HOST_WIDE_INT", "c", ",", "n", ";", "if", "(", "GET_CODE", "(", "arg", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"%<__delay_cycles%> only takes constant arguments\"", ")", ";", "return", "NULL_RTX", ";", "}", "c", "=", "INTVAL", "(", "arg", ")", ";", "gcc_assert", "(", "HOST_BITS_PER_WIDE_INT", ">", "32", ")", ";", "if", "(", "c", "<", "0", ")", "{", "error", "(", "\"%<__delay_cycles%> only takes non-negative cycle counts\"", ")", ";", "return", "NULL_RTX", ";", "}", "emit_insn", "(", "gen_delay_cycles_start", "(", "arg", ")", ")", ";", "if", "(", "c", ">", "2", "*", "0xffff", "+", "1", ")", "{", "n", "=", "(", "c", "-", "2", ")", "/", "2", ";", "c", "-=", "(", "n", "*", "2", ")", "+", "2", ";", "if", "(", "(", "unsigned", "long", "long", ")", "n", ">", "0xffffffffULL", ")", "{", "error", "(", "\"%<__delay_cycles%> is limited to 32-bit loop counts\"", ")", ";", "return", "NULL_RTX", ";", "}", "emit_insn", "(", "gen_delay_cycles_2x_plus2_si", "(", "GEN_INT", "(", "n", ")", ")", ")", ";", "}", "if", "(", "c", ">", "2", ")", "{", "n", "=", "(", "c", "-", "1", ")", "/", "2", ";", "c", "-=", "(", "n", "*", "2", ")", "+", "1", ";", "emit_insn", "(", "gen_delay_cycles_2x_plus1_hi", "(", "GEN_INT", "(", "n", ")", ")", ")", ";", "}", "while", "(", "c", ">", "0", ")", "{", "emit_insn", "(", "gen_delay_cycles_1", "(", ")", ")", ";", "c", "-=", "1", ";", "}", "emit_insn", "(", "gen_delay_cycles_end", "(", "arg", ")", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "one", "or", "more", "delay_cycles_X", "insns", ",", "in", "order", "to", "generate", "code", "that", "delays", "exactly", "ARG", "cycles", "." ]

[ "pru", "\"%<__delay_cycles%> only takes constant arguments\"", "32", "0", "\"%<__delay_cycles%> only takes non-negative cycle counts\"", "2", "0xffff", "1", "2", "2", "2", "2", "0xffffffffULL", "\"%<__delay_cycles%> is limited to 32-bit loop counts\"", "2", "1", "2", "2", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "pdp11_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", "||", "INTVAL", "(", "x", ")", "==", "-", "1", "||", "INTVAL", "(", "x", ")", "==", "1", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "2", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "4", ";", "return", "true", ";", "case", "MULT", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "11", ")", ";", "return", "false", ";", "case", "DIV", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "25", ")", ";", "return", "false", ";", "case", "MOD", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "26", ")", ";", "return", "false", ";", "case", "ABS", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "false", ";", "case", "ZERO_EXTEND", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "case", "SIGN_EXTEND", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "HImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "6", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "false", ";", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "case", "ASHIFTRT", ":", "if", "(", "optimize_size", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "8", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "HImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "if", "(", "abs", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "==", "1", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2.5", "+", "0.5", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "}", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "10", ")", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "2.5", "+", "0.5", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "18", ")", ";", "}", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "This", "tries", "to", "approximate", "what", "pdp11_insn_cost", "would", "do", ",", "but", "without", "visibility", "into", "the", "actual", "instruction", "being", "generated", "it", "'s", "inevitably", "a", "rough", "approximation", "." ]

[ "pdp11", "0", "1", "1", "0", "2", "4", "2", "11", "2", "25", "2", "26", "3", "1", "1", "6", "2", "1", "1", "8", "1", "1", "1", "1", "1", "2.5", "0.5", "1", "10", "1", "2.5", "0.5", "1", "18" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "F2003fInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "!", "Cond", ".", "empty", "(", ")", "&&", "\"Invalid 2003f branch condition!\"", ")", ";", "F2003fCC", "::", "CondCode", "CC", "=", "static_cast", "<", "F2003fCC", "::", "CondCode", ">", "(", "Cond", ".", "back", "(", ")", ".", "getImm", "(", ")", ")", ";", "Cond", ".", "back", "(", ")", "=", "MachineOperand", "::", "CreateImm", "(", "OppositeF2003fCC", "(", "CC", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "F2003f", "F2003f", "\"Invalid 2003f branch condition!\"", "F2003fCC::CondCode", "F2003fCC::CondCode", "F2003f" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "VT", ")", "||", "isSHUFPMask", "(", "M", ",", "VT", ")", "||", "isPSHUFDMask", "(", "M", ",", "VT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "VT", ")", "||", "isPSHUFLWMask", "(", "M", ",", "VT", ")", "||", "isPALIGNRMask", "(", "M", ",", "VT", ",", "Subtarget", "->", "hasSSSE3", "(", ")", ")", "||", "isUNPCKLMask", "(", "M", ",", "VT", ")", "||", "isUNPCKHMask", "(", "M", ",", "VT", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "VT", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "VT", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "64", "2", "0" ]

[]

[ "<s>", "enum", "direction", "ia64_hpux_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "int_size_in_bytes", "(", "type", ")", "<", "UNITS_PER_WORD", ")", "return", "upward", ";", "return", "DEFAULT_FUNCTION_ARG_PADDING", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "For", "the", "HP-UX", "IA64", "aggregate", "parameters", "are", "passed", "stored", "in", "the", "most", "significant", "bits", "of", "the", "stack", "slot", "." ]

[ "ia64" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "AArch64GISelActualAccessor", "*", "GISel", "=", "new", "AArch64GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "new", "AArch64InstructionSelector", "(", "*", "this", ",", "*", "I", ",", "*", "RBI", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "if", "(", "CurrentState", "==", "FunctionStart", ")", "{", "auto", "&", "TOut", "=", "reinterpret_cast", "<", "WebAssemblyTargetStreamer", "&", ">", "(", "*", "Out", ".", "getTargetStreamer", "(", ")", ")", ";", "TOut", ".", "emitLocal", "(", "SmallVector", "<", "wasm", "::", "ValType", ",", "0", ">", "(", ")", ")", ";", "}", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "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", "." ]

[ "WebAssembly", "WebAssembly", "wasm::ValType", "0", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "convertSetCCLogicToBitwiseLogic", "(", "EVT", "VT", ")", "const", "override", "{", "return", "VT", ".", "isScalarInteger", "(", ")", ";", "}", "</s>" ]

[ "Use", "bitwise", "logic", "to", "make", "pairs", "of", "compares", "more", "efficient", "." ]

[ "RI5CY" ]

[]

[ "<s>", "static", "bool", "mips_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_PRECISION", "(", "mode", ")", "<=", "2", "*", "BITS_PER_WORD", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "mips", "2" ]

[]

[ "<s>", "static", "void", "mmix_output_shiftvalue_op_from_str", "(", "FILE", "*", "stream", ",", "const", "char", "*", "mainop", ",", "HOST_WIDEST_INT", "value", ")", "{", "static", "const", "char", "*", "const", "op_part", "[", "]", "=", "{", "\"L\"", ",", "\"ML\"", ",", "\"MH\"", ",", "\"H\"", "}", ";", "int", "i", ";", "if", "(", "!", "mmix_shiftable_wyde_value", "(", "value", ")", ")", "{", "char", "s", "[", "sizeof", "(", "\"0xffffffffffffffff\"", ")", "]", ";", "sprintf", "(", "s", ",", "HOST_WIDEST_INT_PRINT_HEX", ",", "value", ")", ";", "internal_error", "(", "\"MMIX Internal: %s is not a shiftable int\"", ",", "s", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "if", "(", "value", "&", "0xffff", ")", "{", "fprintf", "(", "stream", ",", "\"%s%s\"", ",", "mainop", ",", "op_part", "[", "i", "]", ")", ";", "return", ";", "}", "value", ">>=", "16", ";", "}", "fprintf", "(", "stream", ",", "\"%sL\"", ",", "mainop", ")", ";", "}", "</s>" ]

[ "Print", "operator", "suitable", "for", "doing", "something", "with", "a", "shiftable", "wyde", ".", "The", "type", "of", "operator", "is", "passed", "as", "an", "asm", "output", "modifier", "." ]

[ "mmix", "\"L\"", "\"ML\"", "\"MH\"", "\"H\"", "\"0xffffffffffffffff\"", "\"MMIX Internal: %s is not a shiftable int\"", "0", "4", "0xffff", "\"%s%s\"", "16", "\"%sL\"" ]

[]

[ "<s>", "static", "rtx", "alpha_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "if", "(", "fcode", ">=", "ALPHA_BUILTIN_max", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "arity", "=", "0", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "arity", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "alpha", "0", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "NumOps", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "if", "(", "NumOps", "==", "0", ")", "return", "false", ";", "switch", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "NumOps", "-", "1", "]", ".", "OperandType", ")", "{", "case", "MCOI", "::", "OPERAND_UNKNOWN", ":", "case", "MCOI", "::", "OPERAND_IMMEDIATE", ":", "{", "uint64_t", "Region", "=", "Addr", "&", "~", "uint64_t", "(", "0xfffffff", ")", ";", "Target", "=", "Region", "+", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "case", "MCOI", "::", "OPERAND_PCREL", ":", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "Mips", "0", "1", "0xfffffff", "1", "1" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "ZERO", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "BP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "RM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "||", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", "&&", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "!", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "{", "for", "(", "auto", "Reg", ":", "CSR_Altivec_SaveList", ")", "{", "if", "(", "Reg", "==", "0", ")", "break", ";", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "for", "(", "MCRegAliasIterator", "AS", "(", "Reg", ",", "this", ",", "true", ")", ";", "AS", ".", "isValid", "(", ")", ";", "++", "AS", ")", "{", "Reserved", ".", "set", "(", "*", "AS", ")", ";", "}", "}", "}", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::FP", "PPC::BP", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC", "PPC", "PPC", "PPC::R2", "PPC::R13", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC::R29", "PPC::R30", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass", "0" ]

[]

[ "<s>", "static", "tree", "ix86_mangle_function_version_assembler_name", "(", "tree", "decl", ",", "tree", "id", ")", "{", "tree", "version_attr", ";", "const", "char", "*", "orig_name", ",", "*", "version_string", ";", "char", "*", "attr_str", ",", "*", "assembler_name", ";", "if", "(", "DECL_DECLARED_INLINE_P", "(", "decl", ")", "&&", "lookup_attribute", "(", "\"gnu_inline\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"function versions cannot be marked as gnu_inline,\"", "\" bodies have to be generated\"", ")", ";", "if", "(", "DECL_VIRTUAL_P", "(", "decl", ")", "||", "DECL_VINDEX", "(", "decl", ")", ")", "sorry", "(", "\"virtual function multiversioning not supported\"", ")", ";", "version_attr", "=", "lookup_attribute", "(", "\"target\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "gcc_assert", "(", "version_attr", "!=", "NULL_TREE", ")", ";", "orig_name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "version_string", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "version_attr", ")", ")", ")", ";", "if", "(", "strcmp", "(", "version_string", ",", "\"default\"", ")", "==", "0", ")", "return", "id", ";", "attr_str", "=", "sorted_attr_string", "(", "TREE_VALUE", "(", "version_attr", ")", ")", ";", "assembler_name", "=", "XNEWVEC", "(", "char", ",", "strlen", "(", "orig_name", ")", "+", "strlen", "(", "attr_str", ")", "+", "2", ")", ";", "sprintf", "(", "assembler_name", ",", "\"%s.%s\"", ",", "orig_name", ",", "attr_str", ")", ";", "if", "(", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", ")", "SET_DECL_RTL", "(", "decl", ",", "NULL", ")", ";", "tree", "ret", "=", "get_identifier", "(", "assembler_name", ")", ";", "XDELETEVEC", "(", "attr_str", ")", ";", "XDELETEVEC", "(", "assembler_name", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "This", "function", "changes", "the", "assembler", "name", "for", "functions", "that", "are", "versions", ".", "If", "DECL", "is", "a", "function", "version", "and", "has", "a", "``", "target", "''", "attribute", ",", "it", "appends", "the", "attribute", "string", "to", "its", "assembler", "name", "." ]

[ "i386", "\"gnu_inline\"", "\"function versions cannot be marked as gnu_inline,\"", "\" bodies have to be generated\"", "\"virtual function multiversioning not supported\"", "\"target\"", "\"default\"", "0", "2", "\"%s.%s\"" ]

[]

[ "<s>", "bool", "CheckReturn", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "ArgsFlags", ",", "CCAssignFn", "Fn", ")", "{", "PreAnalyzeReturnForF128", "(", "ArgsFlags", ")", ";", "PreAnalyzeReturnForVectorFloat", "(", "ArgsFlags", ")", ";", "bool", "Return", "=", "CCState", "::", "CheckReturn", "(", "ArgsFlags", ",", "Fn", ")", ";", "OriginalArgWasFloat", ".", "clear", "(", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "OriginalArgWasFloatVector", ".", "clear", "(", ")", ";", "return", "Return", ";", "}", "</s>" ]

[ "CheckReturn", "-", "Analyze", "the", "return", "values", "of", "a", "function", ",", "returning", "true", "if", "the", "return", "can", "be", "performed", "without", "sret-demotion", ",", "and", "false", "otherwise", "." ]

[ "Mips", "ISD::OutputArg" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "out_tsthi", "(", "rtx", "insn", ",", "int", "*", "l", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS1", "(", "tst", ",", "%", "B0", ")", ";", "}", "if", "(", "reg_unused_after", "(", "insn", ",", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS2", "(", "or", ",", "%", "A0", ",", "%", "B0", ")", ";", "}", "if", "(", "test_hard_reg_class", "(", "ADDW_REGS", ",", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS2", "(", "sbiw", ",", "%", "0", ",", "0", ")", ";", "}", "if", "(", "l", ")", "*", "l", "=", "2", ";", "return", "(", "AS2", "(", "cp", ",", "%", "A0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "B0", ",", "__zero_reg__", ")", ")", ";", "}", "</s>" ]

[ "Output", "test", "instruction", "for", "HImode", "." ]

[ "avr", "1", "1", "1", "0", "0", "2" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "instructionsWithoutDebug", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "AArch64::LDRWui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsPairwise", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsPairwise", ",", "IsUnsigned", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", "CostKind", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_start_pool", "(", "struct", "constant_pool", "*", "*", "pool_list", ",", "rtx", "insn", ")", "{", "struct", "constant_pool", "*", "pool", ",", "*", "*", "prev", ";", "pool", "=", "s390_alloc_pool", "(", ")", ";", "pool", "->", "first_insn", "=", "insn", ";", "for", "(", "prev", "=", "pool_list", ";", "*", "prev", ";", "prev", "=", "&", "(", "*", "prev", ")", "->", "next", ")", ";", "*", "prev", "=", "pool", ";", "return", "pool", ";", "}", "</s>" ]

[ "Create", "new", "constant", "pool", "covering", "instructions", "starting", "at", "INSN", "and", "chain", "it", "to", "the", "end", "of", "POOL_LIST", "." ]

[ "s390" ]

[]

[ "<s>", "int64_t", "ARMBaseRegisterInfo", "::", "getFrameIndexInstrOffset", "(", "const", "MachineInstr", "*", "MI", ",", "int", "Idx", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "int64_t", "InstrOffs", "=", "0", ";", ";", "int", "Scale", "=", "1", ";", "unsigned", "ImmIdx", "=", "0", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "case", "ARMII", "::", "AddrMode_i12", ":", "InstrOffs", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "1", ";", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "{", "const", "MachineOperand", "&", "OffOp", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM5Offset", "(", "OffOp", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM5Op", "(", "OffOp", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "Scale", "=", "4", ";", "break", ";", "}", "case", "ARMII", "::", "AddrMode2", ":", "{", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM2Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM2Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "}", "case", "ARMII", "::", "AddrMode3", ":", "{", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM3Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM3Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "}", "case", "ARMII", "::", "AddrModeT1_s", ":", "{", "ImmIdx", "=", "Idx", "+", "1", ";", "InstrOffs", "=", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "4", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "break", ";", "}", "return", "InstrOffs", "*", "Scale", ";", "}", "</s>" ]

[ "Get", "the", "offset", "from", "the", "referenced", "frame", "index", "in", "the", "instruction", ",", "if", "there", "is", "one", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "1", "0", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "ARMII::AddrMode_i12", "1", "1", "ARMII::AddrMode5", "1", "ARM_AM::getAM5Offset", "ARM_AM::getAM5Op", "ARM_AM::sub", "4", "ARMII::AddrMode2", "2", "ARM_AM::getAM2Offset", "ARM_AM::getAM2Op", "ARM_AM::sub", "ARMII::AddrMode3", "2", "ARM_AM::getAM3Offset", "ARM_AM::getAM3Op", "ARM_AM::sub", "ARMII::AddrModeT1_s", "1", "4", "\"Unsupported addressing mode!\"" ]

[]

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

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

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

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableExpandCondsets", ")", "{", "Pass", "*", "Exp", "=", "createHexagonExpandCondsets", "(", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "IdentifyingPassPtr", "(", "Exp", ")", ")", ";", "}", "if", "(", "!", "DisableStoreWidening", ")", "addPass", "(", "createHexagonStoreWidening", "(", ")", ",", "false", ")", ";", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonHardwareLoops", "(", ")", ",", "false", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", ")", "addPass", "(", "&", "MachinePipelinerID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MVT", "PPCTargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", "&&", "VT", "==", "MVT", "::", "f64", ")", "return", "MVT", "::", "i32", ";", "return", "PPCTargetLowering", "::", "getRegisterType", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "PowerPC", "PPC", "MVT::f64", "MVT::i32", "PPC" ]

[]

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

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

[ "SHUXI", "\"SHUXIAsmBackend::relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "unsigned", "SystemZRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::R11D", "SystemZ::R15D" ]

[]

[ "<s>", "static", "NodeType", "*", "getEntryNode", "(", "const", "MCallSubGraph", "&", "G", ")", "{", "return", "G", ".", "getEntryNode", "(", ")", "?", "G", ".", "getEntryNode", "(", ")", ":", "G", ".", "Nodes", ".", "front", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "token", "chain", "corresponding", "to", "the", "entry", "of", "the", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "rtx", "mips_rewrite_small_data", "(", "rtx", "pattern", ")", "{", "pattern", "=", "copy_insn", "(", "pattern", ")", ";", "mips_rewrite_small_data_1", "(", "&", "pattern", ",", "SYMBOL_CONTEXT_LEA", ")", ";", "return", "pattern", ";", "}", "</s>" ]

[ "If", "possible", ",", "rewrite", "OP", "so", "that", "it", "refers", "to", "small", "data", "using", "explicit", "relocations", "." ]

[ "mips" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", ";", "if", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "FullFS", "+=", "\"+fp64-fp16-denormals,\"", ";", "}", "else", "{", "FullFS", "+=", "\"-fp32-denormals,\"", ";", "}", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"+wavefrontsize\"", ")", "!=", "StringRef", "::", "npos", ")", "{", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize16\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize16,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize32\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize32,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize64\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize64,\"", ";", "}", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSize", "==", "0", ")", "WavefrontSize", "=", "64", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "if", "(", "DoesNotSupportXNACK", "&&", "EnableXNACK", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureXNACK", ")", ";", "EnableXNACK", "=", "false", ";", "}", "if", "(", "DoesNotSupportSRAMECC", "&&", "EnableSRAMECC", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureSRAMECC", ")", ";", "EnableSRAMECC", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+sram-ecc,+xnack,\"", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "AMDGPU", "\"+fp64-fp16-denormals,\"", "\"-fp32-denormals,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "64", "AMDGPU", "AMDGPU::FeatureXNACK", "AMDGPU::FeatureSRAMECC" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "return", "TargetInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MBB", ",", "Flags", ")", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "ix86_check_no_addr_space", "(", "rtx", "insn", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "!", "ADDR_SPACE_GENERIC_P", "(", "MEM_ADDR_SPACE", "(", "x", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "false", "if", "INSN", "contains", "a", "MEM", "with", "a", "non-default", "address", "space", "." ]

[ "i386" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUTargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "return", "AMDGPUCallLowering", "::", "CCAssignFnForCall", "(", "CC", ",", "IsVarArg", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "if", "(", "!", "TargetLoweringBase", "::", "shouldReduceLoadWidth", "(", "Load", ",", "ExtTy", ",", "NewVT", ")", ")", "return", "false", ";", "auto", "*", "L", "=", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "int", ">", "BO", "=", "getBaseAndOffset", "(", "L", "->", "getBasePtr", "(", ")", ")", ";", "if", "(", "BO", ".", "first", ".", "getOpcode", "(", ")", "==", "HexagonISD", "::", "CONST32_GP", ")", "return", "false", ";", "if", "(", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "BO", ".", "first", ")", ")", "{", "auto", "&", "HTM", "=", "static_cast", "<", "const", "HexagonTargetMachine", "&", ">", "(", "getTargetMachine", "(", ")", ")", ";", "const", "auto", "*", "GO", "=", "dyn_cast_or_null", "<", "const", "GlobalObject", ">", "(", "GA", "->", "getGlobal", "(", ")", ")", ";", "return", "!", "GO", "||", "!", "HTM", ".", "getObjFileLowering", "(", ")", "->", "isGlobalInSmallSection", "(", "GO", ",", "HTM", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "Hexagon", "Hexagon", "ISD::LoadExtType", "HexagonISD::CONST32_GP", "Hexagon" ]

[]

[ "<s>", "static", "int", "arc_insn_cost", "(", "rtx_insn", "*", "insn", ",", "bool", "speed", ")", "{", "int", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "0", ";", "if", "(", "!", "speed", ")", "return", "get_attr_length", "(", "insn", ")", ";", "cost", "=", "get_attr_cost", "(", "insn", ")", ";", "if", "(", "cost", ">", "0", ")", "return", "cost", ";", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "switch", "(", "type", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "cost", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "break", ";", "default", ":", "cost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Helper", "for", "INSN_COST", ".", "Per", "Segher", "Boessenkool", ":", "rtx_costs", "computes", "the", "cost", "for", "any", "rtx", "(", "an", "insn", ",", "a", "set", ",", "a", "set", "source", ",", "any", "random", "piece", "of", "one", ")", ".", "set_src_cost", ",", "set_rtx_cost", ",", "etc", ".", "are", "helper", "functions", "that", "use", "that", ".", "Those", "functions", "do", "not", "work", "for", "parallels", ".", "Also", ",", "costs", "are", "not", "additive", "like", "this", "simplified", "model", "assumes", ".", "Also", ",", "more", "complex", "backends", "tend", "to", "miss", "many", "cases", "in", "their", "rtx_costs", "function", ".", "Many", "passes", "that", "want", "costs", "want", "to", "know", "the", "cost", "of", "a", "full", "insn", ".", "Like", "combine", ".", "That", "'s", "why", "I", "created", "insn_cost", ":", "it", "solves", "all", "of", "the", "above", "problems", "." ]

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

[]

[ "<s>", "bool", "doMBBSchedRegionsTopDown", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "If", "this", "method", "returns", "true", ",", "handling", "of", "the", "scheduling", "regions", "themselves", "(", "in", "case", "of", "a", "scheduling", "boundary", "in", "MBB", ")", "will", "be", "done", "beginning", "with", "the", "topmost", "region", "of", "MBB", "." ]

[ "SystemZ" ]

[]

[ "<s>", "rtx", "cris_gen_movem_load", "(", "rtx", "src", ",", "rtx", "nregs_rtx", ")", "{", "int", "nregs", "=", "INTVAL", "(", "nregs_rtx", ")", ";", "rtvec", "vec", ";", "int", "eltno", "=", "1", ";", "int", "i", ";", "rtx", "srcreg", "=", "XEXP", "(", "src", ",", "0", ")", ";", "unsigned", "int", "regno", "=", "nregs", "-", "1", ";", "int", "regno_inc", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "srcreg", ")", "==", "POST_INC", ")", "srcreg", "=", "XEXP", "(", "srcreg", ",", "0", ")", ";", "CRIS_ASSERT", "(", "REG_P", "(", "srcreg", ")", ")", ";", "if", "(", "nregs", "==", "1", ")", "return", "gen_movsi", "(", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ",", "src", ")", ";", "vec", "=", "rtvec_alloc", "(", "nregs", "+", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "POST_INC", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "POST_INC", ")", "{", "RTVEC_ELT", "(", "vec", ",", "1", ")", "=", "gen_rtx_SET", "(", "srcreg", ",", "plus_constant", "(", "Pmode", ",", "srcreg", ",", "nregs", "*", "4", ")", ")", ";", "eltno", "++", ";", "}", "src", "=", "replace_equiv_address", "(", "src", ",", "srcreg", ")", ";", "RTVEC_ELT", "(", "vec", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ",", "src", ")", ";", "regno", "+=", "regno_inc", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nregs", ";", "i", "++", ",", "eltno", "++", ")", "{", "RTVEC_ELT", "(", "vec", ",", "eltno", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ",", "adjust_address_nv", "(", "src", ",", "SImode", ",", "i", "*", "4", ")", ")", ";", "regno", "+=", "regno_inc", ";", "}", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "generating", "movem", "from", "mem", "for", "load_multiple", "." ]

[ "cris", "1", "0", "1", "1", "0", "1", "0", "0", "0", "1", "4", "0", "1", "4" ]

[]

[ "<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported code model\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "}", "case", "CodeModel", "::", "Medium", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "if", "(", "IsM68020", ")", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "return", "M680x0II", "::", "MO_ABSOLUTE_ADDRESS", ";", "}", "}", "}", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "M680x0", "M680x0", "\"Unsupported code model\"", "M680x0II::MO_GOTPCREL", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_GOTPCREL", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_ABSOLUTE_ADDRESS" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MipsPreLegalizerCombiner\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MipsPreLegalizerCombiner\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "getBasePointerSaveOffset", "(", ")", "const", "{", "return", "BasePointerSaveOffset", ";", "}", "</s>" ]

[ "getBasePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "base", "pointer", "." ]

[ "PowerPC", "PPC" ]

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "static", "void", "function_arg_record_value_1", "(", "const_tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ",", "struct", "function_arg_record_value_parms", "*", "parms", ",", "bool", "packed_p", ")", "{", "tree", "field", ";", "if", "(", "!", "packed_p", ")", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", "&&", "DECL_PACKED", "(", "field", ")", ")", "{", "packed_p", "=", "true", ";", "break", ";", "}", "}", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "if", "(", "DECL_SIZE", "(", "field", ")", "!=", "0", ")", "{", "if", "(", "integer_zerop", "(", "DECL_SIZE", "(", "field", ")", ")", ")", "continue", ";", "if", "(", "tree_fits_uhwi_p", "(", "bit_position", "(", "field", ")", ")", ")", "bitpos", "+=", "int_bit_position", "(", "field", ")", ";", "}", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "RECORD_TYPE", ")", "function_arg_record_value_1", "(", "TREE_TYPE", "(", "field", ")", ",", "bitpos", ",", "parms", ",", "packed_p", ")", ";", "else", "if", "(", "(", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "field", ")", ")", "||", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "VECTOR_TYPE", ")", "&&", "TARGET_FPU", "&&", "parms", "->", "named", "&&", "!", "packed_p", ")", "{", "if", "(", "parms", "->", "intoffset", "!=", "-", "1", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intslots", ",", "this_slotno", ";", "startbit", "=", "parms", "->", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intslots", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_slotno", "=", "parms", "->", "slotno", "+", "parms", "->", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intslots", ">", "0", "&&", "intslots", ">", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", "{", "intslots", "=", "MAX", "(", "0", ",", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", ";", "parms", "->", "stack", "=", "1", ";", "}", "parms", "->", "nregs", "+=", "intslots", ";", "parms", "->", "intoffset", "=", "-", "1", ";", "}", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "VECTOR_TYPE", "&&", "DECL_MODE", "(", "field", ")", "==", "BLKmode", ")", "parms", "->", "nregs", "+=", "TYPE_VECTOR_SUBPARTS", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "else", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "COMPLEX_TYPE", ")", "parms", "->", "nregs", "+=", "2", ";", "else", "parms", "->", "nregs", "+=", "1", ";", "}", "else", "{", "if", "(", "parms", "->", "intoffset", "==", "-", "1", ")", "parms", "->", "intoffset", "=", "bitpos", ";", "}", "}", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Traverse", "the", "structure", "recursively", "and", "determine", "how", "many", "registers", "will", "be", "required", "." ]

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

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "AVRExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "for", "(", "Block", "&", "MBB", ":", "MF", ")", "{", "bool", "ContinueExpanding", "=", "true", ";", "unsigned", "ExpandCount", "=", "0", ";", "do", "{", "assert", "(", "ExpandCount", "<", "10", "&&", "\"pseudo expand limit reached\"", ")", ";", "bool", "BlockModified", "=", "expandMBB", "(", "MBB", ")", ";", "Modified", "|=", "BlockModified", ";", "ExpandCount", "++", ";", "ContinueExpanding", "=", "BlockModified", ";", "}", "while", "(", "ContinueExpanding", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "0", "10", "\"pseudo expand limit reached\"" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "Ord", "==", "Release", "||", "Ord", "==", "AcquireRelease", "||", "Ord", "==", "SequentiallyConsistent", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall3", "(", "Strex", ",", "Lo", ",", "Hi", ",", "Addr", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall2", "(", "Strex", ",", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", ")", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "OR1KTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "OR1K", "::", "GPRRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "1", "0", "0U", "OR1K::GPRRegClass" ]

[]

[ "<s>", "bool", "sh_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_FPU_ANY", "&&", "(", "(", "mode", "==", "V2SFmode", ")", "||", "(", "mode", "==", "V4SFmode", ")", "||", "(", "mode", "==", "V16SFmode", ")", ")", ")", "return", "true", ";", "else", "if", "(", "TARGET_SHMEDIA", "&&", "(", "(", "mode", "==", "V8QImode", ")", "||", "(", "mode", "==", "V2HImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V2SImode", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "sh" ]

[]

[ "<s>", "static", "int", "cr16_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "enum", "cr16_addrtype", "addrtype", ";", "struct", "cr16_address", "address", ";", "int", "cost", "=", "2", ";", "addrtype", "=", "cr16_decompose_address", "(", "addr", ",", "&", "address", ",", "0", ",", "FALSE", ")", ";", "gcc_assert", "(", "addrtype", "!=", "CR16_INVALID", ")", ";", "switch", "(", "addrtype", ")", "{", "case", "CR16_ABSOLUTE", ":", "cost", "+=", "1", ";", "break", ";", "case", "CR16_REGP_REL", ":", "cost", "+=", "2", ";", "case", "CR16_REG_REL", ":", "cost", "+=", "3", ";", "if", "(", "address", ".", "disp", ")", "cost", "-=", "1", ";", "break", ";", "case", "CR16_INDEX_REGP_REL", ":", "cost", "+=", "7", ";", "if", "(", "address", ".", "disp", ")", "cost", "-=", "1", ";", "default", ":", "break", ";", "}", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n======\\nmacro TARGET_ADDRESS_COST = %d\\n\"", ",", "cost", ")", ";", "debug_rtx", "(", "addr", ")", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "the", "memory", "address", "x", "." ]

[ "cr16", "2", "0", "1", "2", "3", "1", "7", "1", "\"\\n======\\nmacro TARGET_ADDRESS_COST = %d\\n\"" ]

[]

[ "<s>", "int", "aarch64_simd_attr_length_rglist", "(", "machine_mode", "mode", ")", "{", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "/", "UNITS_PER_VREG", ")", "*", "4", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "length", "of", "aarch64_simd_reglist", "<", "mode", ">", ",", "where", "<", "mode", ">", "is", "one", "of", "VSTRUCT", "modes", ":", "OI", ",", "CI", ",", "EI", ",", "or", "XI", "." ]

[ "aarch64", "4" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "TargetLowering", "::", "computeKnownBitsForFrameIndex", "(", "Op", ",", "Known", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "Known", ".", "Zero", ".", "setHighBits", "(", "getSubtarget", "(", ")", "->", "getKnownHighZeroBitsForFrameIndex", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "inline", "const", "mode_suffix_info", "&", "function_instance", "::", "mode_suffix", "(", ")", "const", "{", "return", "mode_suffixes", "[", "mode_suffix_id", "]", ";", "}", "</s>" ]

[ "Return", "information", "about", "the", "function", "'s", "mode", "suffix", "." ]

[ "aarch64" ]

[]

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

[ "Check", "if", "the", "interrupt", "attribute", "is", "set", "for", "a", "function", "." ]

[ "mips", "\"interrupt\"" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "performFAddCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "performFSubCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "performSetCCCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FMAXNUM", ":", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "UMIN", ":", "case", "AMDGPUISD", "::", "FMIN_LEGACY", ":", "case", "AMDGPUISD", "::", "FMAX_LEGACY", ":", "{", "if", "(", "DCI", ".", "getDAGCombineLevel", "(", ")", ">=", "AfterLegalizeDAG", "&&", "N", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "f64", "&&", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "return", "performMinMaxCombine", "(", "N", ",", "DCI", ")", ";", "break", ";", "}", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "ATOMIC_STORE", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP_WITH_SUCCESS", ":", "case", "ISD", "::", "ATOMIC_SWAP", ":", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "case", "AMDGPUISD", "::", "ATOMIC_INC", ":", "case", "AMDGPUISD", "::", "ATOMIC_DEC", ":", "if", "(", "DCI", ".", "isBeforeLegalize", "(", ")", ")", "break", ";", "return", "performMemSDNodeCombine", "(", "cast", "<", "MemSDNode", ">", "(", "N", ")", ",", "DCI", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performAndCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performOrCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "performXorCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "FP_CLASS", ":", "return", "performClassCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FCANONICALIZE", ":", "return", "performFCanonicalizeCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "FRACT", ":", "case", "AMDGPUISD", "::", "RCP", ":", "case", "AMDGPUISD", "::", "RSQ", ":", "case", "AMDGPUISD", "::", "RCP_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_LEGACY", ":", "case", "AMDGPUISD", "::", "RSQ_CLAMP", ":", "case", "AMDGPUISD", "::", "LDEXP", ":", "{", "SDValue", "Src", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Src", ".", "isUndef", "(", ")", ")", "return", "Src", ";", "break", ";", "}", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "performUCharToFloatCombine", "(", "N", ",", "DCI", ")", ";", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE0", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE1", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE2", ":", "case", "AMDGPUISD", "::", "CVT_F32_UBYTE3", ":", "return", "performCvtF32UByteNCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "AMDGPUTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</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", "." ]

[ "AMDGPU", "SI", "AMDGPU", "ISD::FADD", "ISD::FSUB", "ISD::SETCC", "ISD::FMAXNUM", "ISD::FMINNUM", "ISD::SMAX", "ISD::SMIN", "ISD::UMAX", "ISD::UMIN", "AMDGPUISD::FMIN_LEGACY", "AMDGPUISD::FMAX_LEGACY", "0", "MVT::f64", "ISD::LOAD", "ISD::STORE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_STORE", "ISD::ATOMIC_CMP_SWAP", "ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS", "ISD::ATOMIC_SWAP", "ISD::ATOMIC_LOAD_ADD", "ISD::ATOMIC_LOAD_SUB", "ISD::ATOMIC_LOAD_AND", "ISD::ATOMIC_LOAD_OR", "ISD::ATOMIC_LOAD_XOR", "ISD::ATOMIC_LOAD_NAND", "ISD::ATOMIC_LOAD_MIN", "ISD::ATOMIC_LOAD_MAX", "ISD::ATOMIC_LOAD_UMIN", "ISD::ATOMIC_LOAD_UMAX", "AMDGPUISD::ATOMIC_INC", "AMDGPUISD::ATOMIC_DEC", "ISD::AND", "ISD::OR", "ISD::XOR", "AMDGPUISD::FP_CLASS", "ISD::FCANONICALIZE", "AMDGPUISD::FRACT", "AMDGPUISD::RCP", "AMDGPUISD::RSQ", "AMDGPUISD::RCP_LEGACY", "AMDGPUISD::RSQ_LEGACY", "AMDGPUISD::RSQ_CLAMP", "AMDGPUISD::LDEXP", "0", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "AMDGPUISD::CVT_F32_UBYTE0", "AMDGPUISD::CVT_F32_UBYTE1", "AMDGPUISD::CVT_F32_UBYTE2", "AMDGPUISD::CVT_F32_UBYTE3", "AMDGPU" ]

[]

[ "<s>", "static", "inline", "MemOpKey", "getTombstoneKey", "(", ")", "{", "return", "MemOpKey", "(", "PtrInfo", "::", "getTombstoneKey", "(", ")", ",", "PtrInfo", "::", "getTombstoneKey", "(", ")", ",", "PtrInfo", "::", "getTombstoneKey", "(", ")", ",", "PtrInfo", "::", "getTombstoneKey", "(", ")", ",", "PtrInfo", "::", "getTombstoneKey", "(", ")", ")", ";", "}", "</s>" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "HexagonGatherPacketize", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "!", "EnableGatherPacketize", ")", "return", "false", ";", "auto", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "bool", "HasV65", "=", "ST", ".", "hasV65Ops", "(", ")", ";", "bool", "UseHVX", "=", "ST", ".", "useHVXOps", "(", ")", ";", "if", "(", "!", "(", "HasV65", "&", "UseHVX", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "bool", "VtmpDef", "=", "false", ";", "MachineBasicBlock", "::", "iterator", "MII", ",", "MIE", ",", "DefMII", ";", "for", "(", "MII", "=", "MBB", ".", "begin", "(", ")", ",", "MIE", "=", "MBB", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "VtmpDef", ")", "{", "if", "(", "!", "isVtmpUse", "(", "MI", ")", ")", "continue", ";", "MBB", ".", "splice", "(", "std", "::", "next", "(", "DefMII", ")", ",", "&", "MBB", ",", "MII", ")", ";", "finalizeBundle", "(", "MBB", ",", "DefMII", ".", "getInstrIterator", "(", ")", ",", "std", "::", "next", "(", "MII", ")", ".", "getInstrIterator", "(", ")", ")", ";", "VtmpDef", "=", "false", ";", "continue", ";", "}", "if", "(", "!", "(", "isVtmpDef", "(", "MI", ")", ")", ")", "continue", ";", "VtmpDef", "=", "true", ";", "DefMII", "=", "MII", ";", "}", "assert", "(", "!", "VtmpDef", "&&", "\"VTMP producer and consumer not in same block\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"VTMP producer and consumer not in same block\"" ]

[]

[ "<s>", "static", "bool", "nvptx_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "ARG_UNUSED", "(", "aligned_p", ")", ")", "{", "HOST_WIDE_INT", "val", "=", "0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CONST_INT", ":", "nvptx_assemble_value", "(", "INTVAL", "(", "x", ")", ",", "size", ")", ";", "break", ";", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", ";", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "gcc_fallthrough", "(", ")", ";", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "size", "==", "init_frag", ".", "size", ")", ";", "if", "(", "init_frag", ".", "offset", ")", "sorry", "(", "\"cannot emit unaligned pointers in ptx assembly\"", ")", ";", "nvptx_maybe_record_fnsym", "(", "x", ")", ";", "init_frag", ".", "val", "=", "val", ";", "output_init_frag", "(", "x", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "object", "X", "of", "size", "SIZE", "." ]

[ "nvptx", "0", "0", "1", "0", "\"cannot emit unaligned pointers in ptx assembly\"" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "emitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "LVIInlineAsmHardening", ")", "{", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureLVIControlFlowIntegrity", "]", "&&", "applyLVICFIMitigation", "(", "Inst", ")", ")", "return", ";", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureLVILoadHardening", "]", ")", "applyLVILoadHardeningMitigation", "(", "Inst", ",", "Out", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "X86", "X86", "X86::FeatureLVIControlFlowIntegrity", "X86::FeatureLVILoadHardening" ]

[]

[ "<s>", "unsigned", "int", "rs6000_dbx_register_number", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "format", ")", "{", "if", "(", "(", "format", "==", "0", "&&", "dwarf_debuginfo_p", "(", ")", ")", "||", "format", "==", "1", ")", "{", "if", "(", "regno", "<=", "31", ")", "return", "regno", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_FPR_REGNO", "+", "32", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "1124", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "108", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "109", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "101", ";", "if", "(", "format", "==", "1", "&&", "regno", "==", "CR2_REGNO", ")", "return", "64", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "86", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "356", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "67", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", ")", "return", "111", ";", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "67", ";", "if", "(", "regno", "==", "64", ")", "return", "100", ";", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "regno", "<=", "31", ")", "return", "regno", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_FPR_REGNO", "+", "32", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "77", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "65", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "66", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "76", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "68", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "109", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "110", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", ")", "return", "111", ";", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "67", ";", "if", "(", "regno", "==", "64", ")", "return", "64", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "rs6000", "0", "1", "31", "32", "1124", "108", "109", "101", "1", "64", "86", "356", "67", "111", "67", "64", "100", "31", "32", "77", "65", "66", "76", "68", "109", "110", "111", "67", "64", "64" ]

[]

[ "<s>", "StackOffset", "X86FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "if", "(", "!", "IgnoreSPUpdates", "&&", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getTCReturnAddrDelta", "(", ")", ">=", "0", "&&", "\"we don't handle this case!\"", ")", ";", "return", "getFrameIndexReferenceSP", "(", "MF", ",", "FI", ",", "FrameReg", ",", "StackSize", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "X86", "X86", "X86", "0", "\"we don't handle this case!\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_delegitimize_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", ",", "y", ",", "offset", ";", "orig_x", "=", "delegitimize_mem_from_attrs", "(", "orig_x", ")", ";", "x", "=", "orig_x", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "y", "=", "x", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", "&&", "GET_CODE", "(", "y", ")", "==", "LO_SUM", ")", "y", "=", "XEXP", "(", "y", ",", "1", ")", ";", "offset", "=", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "PLUS", "&&", "GET_MODE", "(", "y", ")", "==", "Pmode", "&&", "CONST_INT_P", "(", "XEXP", "(", "y", ",", "1", ")", ")", ")", "{", "offset", "=", "XEXP", "(", "y", ",", "1", ")", ";", "y", "=", "XEXP", "(", "y", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", "&&", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "y", "=", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ";", "if", "(", "TARGET_XCOFF", "&&", "GET_CODE", "(", "y", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "y", ")", "&&", "rs6000_real_tls_symbol_ref_p", "(", "get_pool_constant", "(", "y", ")", ")", ")", "return", "orig_x", ";", "if", "(", "offset", "!=", "NULL_RTX", ")", "y", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "y", ",", "offset", ")", ";", "if", "(", "!", "MEM_P", "(", "orig_x", ")", ")", "return", "y", ";", "else", "return", "replace_equiv_address_nv", "(", "orig_x", ",", "y", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "GET_CODE", "(", "orig_x", ")", "==", "LO_SUM", "&&", "GET_CODE", "(", "XEXP", "(", "orig_x", ",", "1", ")", ")", "==", "CONST", ")", "{", "y", "=", "XEXP", "(", "XEXP", "(", "orig_x", ",", "1", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", "&&", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_MACHOPIC_OFFSET", ")", "return", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ";", "}", "return", "orig_x", ";", "}", "</s>" ]

[ "In", "the", "name", "of", "slightly", "smaller", "debug", "output", ",", "and", "to", "cater", "to", "general", "assembler", "lossage", ",", "recognize", "various", "UNSPEC", "sequences", "and", "turn", "them", "back", "into", "a", "direct", "symbol", "reference", "." ]

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

[]

[ "<s>", "Optional", "<", "Instruction", "*", ">", "AArch64TTIImpl", "::", "instCombineIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ")", "const", "{", "Intrinsic", "::", "ID", "IID", "=", "II", ".", "getIntrinsicID", "(", ")", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_sve_convert_from_svbool", ":", "return", "instCombineConvertFromSVBool", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "instCombineSVEDup", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne", ":", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "instCombineSVECmpNE", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_rdffr", ":", "return", "instCombineRDFFR", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lasta", ":", "case", "Intrinsic", "::", "aarch64_sve_lastb", ":", "return", "instCombineSVELast", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "2", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "4", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "8", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntb", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "16", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_first", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_last", ":", "return", "instCombineSVEPTest", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "case", "Intrinsic", "::", "aarch64_sve_fmul", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_uunpklo", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpklo", ":", "return", "instCombineSVEUnpack", "(", "IC", ",", "II", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "their", "own", "combinations", "for", "target-specific", "intrinsics", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "Intrinsic::aarch64_sve_convert_from_svbool", "Intrinsic::aarch64_sve_dup", "Intrinsic::aarch64_sve_cmpne", "Intrinsic::aarch64_sve_cmpne_wide", "Intrinsic::aarch64_sve_rdffr", "Intrinsic::aarch64_sve_lasta", "Intrinsic::aarch64_sve_lastb", "Intrinsic::aarch64_sve_cntd", "2", "Intrinsic::aarch64_sve_cntw", "4", "Intrinsic::aarch64_sve_cnth", "8", "Intrinsic::aarch64_sve_cntb", "16", "Intrinsic::aarch64_sve_ptest_any", "Intrinsic::aarch64_sve_ptest_first", "Intrinsic::aarch64_sve_ptest_last", "Intrinsic::aarch64_sve_mul", "Intrinsic::aarch64_sve_fmul", "Intrinsic::aarch64_sve_tbl", "Intrinsic::aarch64_sve_uunpkhi", "Intrinsic::aarch64_sve_uunpklo", "Intrinsic::aarch64_sve_sunpkhi", "Intrinsic::aarch64_sve_sunpklo" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "RegName", "=", "[", "]", "(", "unsigned", "Reg", ")", "{", "if", "(", "Reg", ")", "return", "LoongArchInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "else", "return", "\"noreg\"", ";", "}", ";", "switch", "(", "Kind", ")", "{", "case", "KindTy", "::", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"<register \"", "<<", "RegName", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "KindTy", "::", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "\"noreg\"", "\"<register \"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "bool", "isPPC64", "(", ")", "const", "{", "Triple", "TT", "(", "getTargetTriple", "(", ")", ")", ";", "return", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", "||", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "is", "64-bit", "PowerPC", "(", "little", "and", "big", "endian", ")", "." ]

[ "PowerPC", "PPC" ]

[]