Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "parallel", "*", "nvptx_find_par", "(", "bb_insn_map_t", "*", "map", ",", "parallel", "*", "par", ",", "basic_block", "block", ")", "{", "if", "(", "block", "->", "flags", "&", "BB_VISITED", ")", "return", "par", ";", "block", "->", "flags", "|=", "BB_VISITED", ";", "if", "(", "rtx_insn", "*", "*", "endp", "=", "map", "->", "get", "(", "block", ")", ")", "{", "rtx_insn", "*", "end", "=", "*", "endp", ";", "switch", "(", "recog_memoized", "(", "end", ")", ")", "{", "case", "CODE_FOR_return", ":", "return", "par", ";", "case", "CODE_FOR_nvptx_forked", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "mask", ")", ";", "par", "=", "new", "parallel", "(", "par", ",", "mask", ")", ";", "par", "->", "forked_block", "=", "block", ";", "par", "->", "forked_insn", "=", "end", ";", "if", "(", "nvptx_needs_shared_bcast", "(", "mask", ")", ")", "par", "->", "fork_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_fork", ")", ";", "}", "break", ";", "case", "CODE_FOR_nvptx_join", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "par", "->", "mask", "==", "mask", ")", ";", "par", "->", "join_block", "=", "block", ";", "par", "->", "join_insn", "=", "end", ";", "if", "(", "nvptx_needs_shared_bcast", "(", "mask", ")", ")", "par", "->", "joining_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_joining", ")", ";", "par", "=", "par", "->", "parent", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "par", ")", "par", "->", "blocks", ".", "safe_push", "(", "block", ")", ";", "else", "par", "=", "new", "parallel", "(", "0", ",", "0", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "block", "->", "succs", ")", "nvptx_find_par", "(", "map", ",", "par", ",", "e", "->", "dest", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_find_par", "'", "." ]

[ "nvptx", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "isAndroid", "(", ")", "const", "{", "return", "IsAndroid", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "is", "Android", "." ]

[ "Mips" ]

[]

[ "<s>", "MCS51", "::", "Fixups", "MCS51MCExpr", "::", "getFixupKind", "(", ")", "const", "{", "MCS51", "::", "Fixups", "Kind", "=", "MCS51", "::", "Fixups", "::", "LastTargetFixupKind", ";", "switch", "(", "getKind", "(", ")", ")", "{", "case", "VK_MCS51_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_lo8_ldi_neg", ":", "MCS51", "::", "fixup_lo8_ldi", ";", "break", ";", "case", "VK_MCS51_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_hi8_ldi_neg", ":", "MCS51", "::", "fixup_hi8_ldi", ";", "break", ";", "case", "VK_MCS51_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_hh8_ldi_neg", ":", "MCS51", "::", "fixup_hh8_ldi", ";", "break", ";", "case", "VK_MCS51_HHI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_ms8_ldi_neg", ":", "MCS51", "::", "fixup_ms8_ldi", ";", "break", ";", "case", "VK_MCS51_PM_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_lo8_ldi_pm_neg", ":", "MCS51", "::", "fixup_lo8_ldi_pm", ";", "break", ";", "case", "VK_MCS51_PM_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_hi8_ldi_pm_neg", ":", "MCS51", "::", "fixup_hi8_ldi_pm", ";", "break", ";", "case", "VK_MCS51_PM_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "MCS51", "::", "fixup_hh8_ldi_pm_neg", ":", "MCS51", "::", "fixup_hh8_ldi_pm", ";", "break", ";", "case", "VK_MCS51_PM", ":", "case", "VK_MCS51_GS", ":", "Kind", "=", "MCS51", "::", "fixup_16_pm", ";", "break", ";", "case", "VK_MCS51_LO8_GS", ":", "Kind", "=", "MCS51", "::", "fixup_lo8_ldi_gs", ";", "break", ";", "case", "VK_MCS51_HI8_GS", ":", "Kind", "=", "MCS51", "::", "fixup_hi8_ldi_gs", ";", "break", ";", "case", "VK_MCS51_None", ":", "llvm_unreachable", "(", "\"Uninitialized expression\"", ")", ";", "}", "return", "Kind", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "MCS51", "MCS51::Fixups", "MCS51", "MCS51::Fixups", "MCS51::Fixups", "MCS51", "MCS51::fixup_lo8_ldi_neg", "MCS51::fixup_lo8_ldi", "MCS51", "MCS51::fixup_hi8_ldi_neg", "MCS51::fixup_hi8_ldi", "MCS51", "MCS51::fixup_hh8_ldi_neg", "MCS51::fixup_hh8_ldi", "MCS51", "MCS51::fixup_ms8_ldi_neg", "MCS51::fixup_ms8_ldi", "MCS51", "MCS51::fixup_lo8_ldi_pm_neg", "MCS51::fixup_lo8_ldi_pm", "MCS51", "MCS51::fixup_hi8_ldi_pm_neg", "MCS51::fixup_hi8_ldi_pm", "MCS51", "MCS51::fixup_hh8_ldi_pm_neg", "MCS51::fixup_hh8_ldi_pm", "MCS51", "MCS51", "MCS51::fixup_16_pm", "MCS51", "MCS51::fixup_lo8_ldi_gs", "MCS51", "MCS51::fixup_hi8_ldi_gs", "MCS51", "\"Uninitialized expression\"" ]

[]

[ "<s>", "static", "bool", "pa_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "28", "||", "(", "!", "TARGET_SOFT_FLOAT", "&&", "regno", "==", "32", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "pa", "28", "32" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_V128", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "FUNCREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_FUNCREF", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXTERNREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_EXTERNREF", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXNREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_EXNREF", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_F64", "WebAssembly::V128RegClass", "WebAssembly::COPY_V128", "WebAssembly::FUNCREFRegClass", "WebAssembly::COPY_FUNCREF", "WebAssembly::EXTERNREFRegClass", "WebAssembly::COPY_EXTERNREF", "WebAssembly::EXNREFRegClass", "WebAssembly::COPY_EXNREF", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "static", "machine_mode", "s390_promote_function_mode", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_LONG", ")", "{", "if", "(", "type", "!=", "NULL_TREE", "&&", "POINTER_TYPE_P", "(", "type", ")", ")", "*", "punsignedp", "=", "POINTERS_EXTEND_UNSIGNED", ";", "return", "Pmode", ";", "}", "return", "mode", ";", "}", "</s>" ]

[ "Function", "arguments", "and", "return", "values", "are", "promoted", "to", "word", "size", "." ]

[ "s390" ]

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "static", "void", "arm_asm_init_sections", "(", "void", ")", "{", "exception_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.handlerdata\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INITIALIZE_SECTIONS", "." ]

[ "arm", "0", "\"\\t.handlerdata\"" ]

[]

[ "<s>", "void", "LEGMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "getSize", "(", ")", "!=", "4", ")", "{", "llvm_unreachable", "(", "\"Unexpected instruction size!\"", ")", ";", "}", "const", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitConstant", "(", "Binary", ",", "Desc", ".", "getSize", "(", ")", ",", "OS", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "4", "\"Unexpected instruction size!\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsatext\"", "||", "IDVal", "==", "\".text\"", ")", "return", "ParseSectionDirectiveHSAText", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".hsatext\"", "\".text\"" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "static", "SDValue", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "const", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "RVLocs", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ",", "4", ">", "ResultMemLocs", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "ResultMemLocs", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocMemOffset", "(", ")", ",", "InVals", ".", "size", "(", ")", ")", ")", ";", "InVals", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ResultMemLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "offset", "=", "ResultMemLocs", "[", "i", "]", ".", "first", ";", "unsigned", "index", "=", "ResultMemLocs", "[", "i", "]", ".", "second", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "DAG", ".", "getConstant", "(", "offset", "/", "4", ",", "dl", ",", "MVT", "::", "i32", ")", "}", ";", "SDValue", "load", "=", "DAG", ".", "getNode", "(", "XCoreISD", "::", "LDWSP", ",", "dl", ",", "VTs", ",", "Ops", ")", ";", "InVals", "[", "index", "]", "=", "load", ";", "MemOpChains", ".", "push_back", "(", "load", ".", "getValue", "(", "1", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "XCore", "4", "0", "1", "2", "0", "4", "0", "MVT::i32", "MVT::Other", "4", "MVT::i32", "XCoreISD::LDWSP", "1", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_function_arg_alignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "type", ")", "return", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "return", "0", ";", "gcc_assert", "(", "TYPE_MODE", "(", "type", ")", "==", "mode", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "unsigned", "int", "alignment", "=", "0", ";", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "alignment", "=", "std", "::", "max", "(", "alignment", ",", "DECL_ALIGN", "(", "field", ")", ")", ";", "return", "alignment", ";", "}", "</s>" ]

[ "Given", "MODE", "and", "TYPE", "of", "a", "function", "argument", ",", "return", "the", "alignment", "in", "bits", ".", "The", "idea", "is", "to", "suppress", "any", "stronger", "alignment", "requested", "by", "the", "user", "and", "opt", "for", "the", "natural", "alignment", "(", "specified", "in", "AAPCS64", "\\S", "4.1", ")", ".", "This", "is", "a", "helper", "function", "for", "local", "use", "only", "." ]

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

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Alpha", "::", "F4RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "F8RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDT", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "GPRCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "LDQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "llvm_unreachable", "(", "\"Unhandled register class\"", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::F4RCRegisterClass", "Alpha::LDS", "Alpha::F31", "Alpha::F8RCRegisterClass", "Alpha::LDT", "Alpha::F31", "Alpha::GPRCRegisterClass", "Alpha::LDQ", "Alpha::F31", "\"Unhandled register class\"" ]

[]

[ "<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "oldval", ",", "rtx", "newval", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label1", ",", "label2", ",", "x", ",", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "scratch", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "operation", "." ]

[ "alpha", "0", "0" ]

[]

[ "<s>", "static", "rtx", "sh_delegitimize_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", ",", "y", ";", "orig_x", "=", "delegitimize_mem_from_attrs", "(", "orig_x", ")", ";", "x", "=", "orig_x", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "y", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_GOTOFF", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_SYMOFF", ")", "return", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ";", "else", "if", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_PCREL_SYMOFF", ")", "{", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ")", "==", "CONST", ")", "{", "rtx", "symplt", "=", "XEXP", "(", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symplt", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "symplt", ",", "1", ")", "==", "UNSPEC_PLT", "||", "XINT", "(", "symplt", ",", "1", ")", "==", "UNSPEC_PCREL", ")", ")", "return", "XVECEXP", "(", "symplt", ",", "0", ",", "0", ")", ";", "}", "}", "else", "if", "(", "TARGET_SHMEDIA", "&&", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_EXTRACT_S16", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_EXTRACT_U16", ")", ")", "{", "rtx", "offset", "=", "XVECEXP", "(", "y", ",", "0", ",", "1", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ",", "offset", ")", ";", "if", "(", "MEM_P", "(", "orig_x", ")", ")", "x", "=", "replace_equiv_address_nv", "(", "orig_x", ",", "x", ")", ";", "return", "x", ";", "}", "}", "}", "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", "." ]

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

[]

[ "<s>", "const", "MachineOperand", "*", "getNamedOperand", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpName", ")", "const", "{", "return", "getNamedOperand", "(", "const_cast", "<", "MachineInstr", "&", ">", "(", "MI", ")", ",", "OpName", ")", ";", "}", "</s>" ]

[ "Returns", "the", "operand", "named", "Op", "." ]

[ "HSAIL" ]

[]

[ "<s>", "static", "bool", "rs6000_is_costly_dependence", "(", "dep_t", "dep", ",", "int", "cost", ",", "int", "distance", ")", "{", "rtx", "insn", ";", "rtx", "next", ";", "rtx", "load_mem", ",", "str_mem", ";", "if", "(", "rs6000_sched_costly_dep", "==", "no_dep_costly", ")", "return", "false", ";", "if", "(", "rs6000_sched_costly_dep", "==", "all_deps_costly", ")", "return", "true", ";", "insn", "=", "DEP_PRO", "(", "dep", ")", ";", "next", "=", "DEP_CON", "(", "dep", ")", ";", "if", "(", "rs6000_sched_costly_dep", "==", "store_to_load_dep_costly", "&&", "is_load_insn", "(", "next", ",", "&", "load_mem", ")", "&&", "is_store_insn", "(", "insn", ",", "&", "str_mem", ")", ")", "return", "true", ";", "if", "(", "rs6000_sched_costly_dep", "==", "true_store_to_load_dep_costly", "&&", "is_load_insn", "(", "next", ",", "&", "load_mem", ")", "&&", "is_store_insn", "(", "insn", ",", "&", "str_mem", ")", "&&", "DEP_TYPE", "(", "dep", ")", "==", "REG_DEP_TRUE", "&&", "mem_locations_overlap", "(", "str_mem", ",", "load_mem", ")", ")", "return", "true", ";", "if", "(", "rs6000_sched_costly_dep", "<=", "max_dep_latency", "&&", "(", "(", "cost", "-", "distance", ")", ">=", "(", "int", ")", "rs6000_sched_costly_dep", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "the", "dependence", "between", "INSN", "and", "NEXT", "is", "considered", "costly", "by", "the", "given", "target", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "cris_notice_update_cc", "(", "rtx", "exp", ",", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_cc", "attrval", "=", "get_attr_cc", "(", "insn", ")", ";", "if", "(", "TARGET_CCINIT", ")", "{", "CC_STATUS_INIT", ";", "if", "(", "attrval", "==", "CC_REV", ")", "cc_status", ".", "flags", "=", "CC_REVERSED", ";", "return", ";", "}", "switch", "(", "attrval", ")", "{", "case", "CC_NONE", ":", "if", "(", "GET_CODE", "(", "exp", ")", "==", "SET", ")", "{", "if", "(", "cc_status", ".", "value1", "&&", "modified_in_p", "(", "cc_status", ".", "value1", ",", "insn", ")", ")", "cc_status", ".", "value1", "=", "0", ";", "if", "(", "cc_status", ".", "value2", "&&", "modified_in_p", "(", "cc_status", ".", "value2", ",", "insn", ")", ")", "cc_status", ".", "value2", "=", "0", ";", "}", "return", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "return", ";", "case", "CC_REV", ":", "case", "CC_NOOV32", ":", "case", "CC_NORMAL", ":", "cris_normal_notice_update_cc", "(", "exp", ",", "insn", ")", ";", "if", "(", "attrval", "==", "CC_NOOV32", "&&", "TARGET_V32", ")", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "return", ";", "default", ":", "internal_error", "(", "\"unknown cc_attr value\"", ")", ";", "}", "CC_STATUS_INIT", ";", "}", "</s>" ]

[ "This", "function", "looks", "into", "the", "pattern", "to", "see", "how", "this", "insn", "affects", "condition", "codes", ".", "Used", "when", "to", "eliminate", "test", "insns", "before", "a", "condition-code", "user", ",", "such", "as", "a", "``", "scc", "''", "insn", "or", "a", "conditional", "branch", ".", "This", "includes", "checking", "if", "the", "entities", "that", "cc", "was", "updated", "by", ",", "are", "changed", "by", "the", "operation", ".", "Currently", "a", "jumble", "of", "the", "old", "peek-inside-the-insn", "and", "the", "newer", "check-cc-attribute", "methods", "." ]

[ "cris", "0", "0", "\"unknown cc_attr value\"" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCInstFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "llvm_unreachable", "(", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "AMDGPUOperand", "&", "Operand", "=", "(", "AMDGPUOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_addr64", ":", "return", "Operand", ".", "isAddr64", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_gds", ":", "return", "Operand", ".", "isGDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_lds", ":", "return", "Operand", ".", "isLDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_glc", ":", "return", "Operand", ".", "isGLC", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_d16", ":", "return", "Operand", ".", "isD16", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_idxen", ":", "return", "Operand", ".", "isIdxen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_offen", ":", "return", "Operand", ".", "isOffen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcB32", ":", "return", "Operand", ".", "isSSrcB32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcF32", ":", "return", "Operand", ".", "isSSrcF32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SoppBrTarget", ":", "return", "Operand", ".", "isSoppBrTarget", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_VReg32OrOff", ":", "return", "Operand", ".", "isVReg32OrOff", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_InterpSlot", ":", "return", "Operand", ".", "isInterpSlot", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_Attr", ":", "return", "Operand", ".", "isInterpAttr", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_AttrChan", ":", "return", "Operand", ".", "isAttrChan", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "TL45FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "Register", "SPReg", "=", "TL45", "::", "sp", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TL45", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "adjustReg", "(", "MBB", ",", "MI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45::sp", "0", "0", "TL45::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "EVT", "SITargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

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

[ "R600", "SI", "MVT::i1" ]

[]

[ "<s>", "void", "TVMFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "LLVMContext", "&", "C", "=", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "TraceCalls", ")", "return", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"tvm_raw_func\"", ")", "&&", "StackSize", ")", "{", "report_fatal_error", "(", "\"Raw function requires stack\"", ")", ";", "return", ";", "}", "auto", "InsertPt", "=", "llvm", "::", "find_if", "(", "MBB", ",", "[", "&", "]", "(", "auto", "&", "pt", ")", "{", "return", "!", "TVM", "::", "isArgument", "(", "pt", ")", ";", "}", ")", ";", "DebugLoc", "DL", ";", "if", "(", "TraceCalls", ")", "{", "const", "Function", "&", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "MBB", ".", "getBasicBlock", "(", ")", "==", "&", "Fn", ".", "getEntryBlock", "(", ")", ")", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "LOGSTR", ")", ")", ".", "addGlobalAddress", "(", "&", "Fn", ")", ";", "}", "unsigned", "RegFrameBase", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "GETGLOB", ")", ",", "RegFrameBase", ")", ".", "addImm", "(", "5", ")", ";", "unsigned", "RegFrameBaseNew", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "if", "(", "StackSize", "<=", "128", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "ADDCONST", ")", ",", "RegFrameBaseNew", ")", ".", "addReg", "(", "RegFrameBase", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "}", "else", "{", "unsigned", "RegStSize", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "CONST_I257", ")", ",", "RegStSize", ")", ".", "addCImm", "(", "cimm", "(", "C", ",", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "SUB", ")", ",", "RegFrameBaseNew", ")", ".", "addReg", "(", "RegFrameBase", ")", ".", "addReg", "(", "RegStSize", ")", ";", "}", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "TVM", "::", "SETGLOB", ")", ")", ".", "addReg", "(", "RegFrameBaseNew", ")", ".", "addImm", "(", "5", ")", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "TVM", "0", "\"tvm_raw_func\"", "\"Raw function requires stack\"", "TVM::isArgument", "TVM::LOGSTR", "TVM::I257RegClass", "TVM::GETGLOB", "5", "TVM::I257RegClass", "128", "TVM::ADDCONST", "TVM::I257RegClass", "TVM::CONST_I257", "TVM::SUB", "TVM::SETGLOB", "5" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "}", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "OutStreamer", ".", "EmitRawText", "(", "\"@\"", "+", "MF", ".", "getName", "(", ")", "+", "\":\"", ")", ";", "}", "const", "MCSectionELF", "*", "ConfigSection", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "ConfigSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "EmitProgramInfoSI", "(", "MF", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "\"@\"", "\":\"", "\".AMDGPU.config\"", "0", "SI" ]

[]

[ "<s>", "bool", "KudeyarFrameLowering", "::", "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", "." ]

[ "Kudeyar", "Kudeyar" ]

[]

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

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPUAlwaysInlinePass", "::", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", "AM", ")", "{", "alwaysInlineImpl", "(", "M", ",", "GlobalOpt", ")", ";", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "DAG", "->", "addMutation", "(", "ST", ".", "createFillMFMAShadowMutation", "(", "DAG", "->", "TII", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "sparc_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_ARCH32", ")", "return", "(", "(", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", ")", "||", "mode", "==", "SCmode", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", ";", "else", "return", "(", "(", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "16", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "16", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_PASS_BY_REFERENCE", "target", "hook", ".", "Specify", "whether", "to", "pass", "the", "argument", "by", "reference", "." ]

[ "sparc", "8", "8", "16", "16" ]

[]

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

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

[ "CAHP", "\"CAHP Assembly Printer\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "usesConstantBus", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineOperand", "&", "MO", ",", "const", "MCOperandInfo", "&", "OpInfo", ")", "const", "{", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "!", "isInlineConstant", "(", "MO", ",", "OpInfo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isUse", "(", ")", ")", "return", "false", ";", "if", "(", "MO", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "return", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "SGPR_NULL", ")", "return", "false", ";", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "{", "return", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC_LO", ";", "}", "else", "{", "return", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "SI", "AMDGPU::SGPR_NULL", "AMDGPU::M0", "AMDGPU::VCC", "AMDGPU::VCC_LO", "AMDGPU::SReg_32RegClass", "AMDGPU::SReg_64RegClass" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Restores", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs", ",", "CSI", ",", "TRI", ")", ";", "unsigned", "PopOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDMIA_UPD", ":", "ARM", "::", "LDMIA_UPD", ";", "unsigned", "LdrOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDR_POST", ":", "ARM", "::", "LDR_POST_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VLDMDIA_UPD", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "isVarArg", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea2Register", ",", "0", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea1Register", ",", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::t2LDMIA_UPD", "ARM::LDMIA_UPD", "ARM::t2LDR_POST", "ARM::LDR_POST_IMM", "ARM::VLDMDIA_UPD", "0", "ARM", "ARM", "0", "ARM", "0" ]

[]

[ "<s>", "void", "tilepro_expand_unaligned_load", "(", "rtx", "dest_reg", ",", "rtx", "mem", ",", "HOST_WIDE_INT", "bitsize", ",", "HOST_WIDE_INT", "bit_offset", ",", "bool", "sign", ")", "{", "machine_mode", "mode", ";", "rtx", "addr_lo", ",", "addr_hi", ";", "rtx", "mem_lo", ",", "mem_hi", ",", "hi", ";", "rtx", "mema", ",", "wide_result", ";", "int", "last_byte_offset", ";", "HOST_WIDE_INT", "byte_offset", "=", "bit_offset", "/", "BITS_PER_UNIT", ";", "mode", "=", "GET_MODE", "(", "dest_reg", ")", ";", "hi", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "bitsize", "==", "2", "*", "BITS_PER_UNIT", "&&", "(", "bit_offset", "%", "BITS_PER_UNIT", ")", "==", "0", ")", "{", "rtx", "lo", ";", "mem_lo", "=", "adjust_address", "(", "mem", ",", "QImode", ",", "byte_offset", ")", ";", "mem_hi", "=", "adjust_address", "(", "mem", ",", "QImode", ",", "byte_offset", "+", "1", ")", ";", "lo", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_zero_extendqisi2", "(", "lo", ",", "mem_lo", ")", ")", ";", "if", "(", "sign", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_extendqisi2", "(", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "mem_hi", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "gen_lowpart", "(", "SImode", ",", "lo", ")", ",", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_zero_extendqisi2", "(", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "mem_hi", ")", ")", ";", "emit_insn", "(", "gen_insn_intlb", "(", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "gen_lowpart", "(", "SImode", ",", "lo", ")", ")", ")", ";", "}", "return", ";", "}", "mema", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "addr_lo", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "mema", ",", "byte_offset", ")", ")", ";", "mem_lo", "=", "change_address", "(", "mem", ",", "mode", ",", "gen_rtx_AND", "(", "Pmode", ",", "addr_lo", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "set_mem_alias_set", "(", "mem_lo", ",", "0", ")", ";", "last_byte_offset", "=", "(", "bit_offset", "+", "bitsize", "-", "1", ")", "/", "BITS_PER_UNIT", ";", "addr_hi", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "mema", ",", "last_byte_offset", ")", ")", ";", "mem_hi", "=", "change_address", "(", "mem", ",", "mode", ",", "gen_rtx_AND", "(", "Pmode", ",", "addr_hi", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "set_mem_alias_set", "(", "mem_hi", ",", "0", ")", ";", "if", "(", "bitsize", "==", "32", ")", "{", "addr_lo", "=", "make_safe_from", "(", "addr_lo", ",", "dest_reg", ")", ";", "wide_result", "=", "dest_reg", ";", "}", "else", "{", "wide_result", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "emit_move_insn", "(", "hi", ",", "mem_hi", ")", ";", "emit_move_insn", "(", "wide_result", ",", "mem_lo", ")", ";", "emit_insn", "(", "gen_insn_dword_align", "(", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "addr_lo", ")", ")", ";", "if", "(", "bitsize", "!=", "32", ")", "{", "rtx", "extracted", "=", "extract_bit_field", "(", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "bitsize", ",", "bit_offset", "%", "BITS_PER_UNIT", ",", "!", "sign", ",", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "SImode", ",", "SImode", ",", "false", ",", "NULL", ")", ";", "if", "(", "extracted", "!=", "dest_reg", ")", "emit_move_insn", "(", "dest_reg", ",", "gen_lowpart", "(", "SImode", ",", "extracted", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "unaligned", "loads", "." ]

[ "tilepro", "2", "0", "1", "8", "0", "4", "0", "1", "4", "0", "32", "32" ]

[]

[ "<s>", "static", "rtx", "sched_get_mem_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "must_read_p", ",", "bool", "must_write_p", ")", "{", "bool", "opx_p", ";", "bool", "opy_p", ";", "opx_p", "=", "false", ";", "opy_p", "=", "false", ";", "if", "(", "must_read_p", ")", "{", "opx_p", "=", "true", ";", "opy_p", "=", "true", ";", "}", "if", "(", "must_write_p", ")", "{", "opx_p", "=", "true", ";", "opy_p", "=", "false", ";", "}", "if", "(", "opy_p", "&&", "sched_mem_operand_p", "(", "insn", ",", "false", ")", ")", "return", "sched_get_operand", "(", "insn", ",", "false", ")", ";", "if", "(", "opx_p", "&&", "sched_mem_operand_p", "(", "insn", ",", "true", ")", ")", "return", "sched_get_operand", "(", "insn", ",", "true", ")", ";", "gcc_unreachable", "(", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", ",", "if", "it", "is", "a", "MEM", ",", "or", "NULL", "overwise", "." ]

[ "m68k" ]

[]

[ "<s>", "static", "enum", "attr_op_type", "sched_get_opxy_mem_type", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "if", "(", "opx_p", ")", "{", "switch", "(", "get_attr_opx_type", "(", "insn", ")", ")", "{", "case", "OPX_TYPE_NONE", ":", "case", "OPX_TYPE_RN", ":", "case", "OPX_TYPE_FPN", ":", "case", "OPX_TYPE_IMM_Q", ":", "case", "OPX_TYPE_IMM_W", ":", "case", "OPX_TYPE_IMM_L", ":", "return", "OP_TYPE_RN", ";", "case", "OPX_TYPE_MEM1", ":", "case", "OPX_TYPE_MEM234", ":", "case", "OPX_TYPE_MEM5", ":", "case", "OPX_TYPE_MEM7", ":", "return", "OP_TYPE_MEM1", ";", "case", "OPX_TYPE_MEM6", ":", "return", "OP_TYPE_MEM6", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "get_attr_opy_type", "(", "insn", ")", ")", "{", "case", "OPY_TYPE_NONE", ":", "case", "OPY_TYPE_RN", ":", "case", "OPY_TYPE_FPN", ":", "case", "OPY_TYPE_IMM_Q", ":", "case", "OPY_TYPE_IMM_W", ":", "case", "OPY_TYPE_IMM_L", ":", "return", "OP_TYPE_RN", ";", "case", "OPY_TYPE_MEM1", ":", "case", "OPY_TYPE_MEM234", ":", "case", "OPY_TYPE_MEM5", ":", "case", "OPY_TYPE_MEM7", ":", "return", "OP_TYPE_MEM1", ";", "case", "OPY_TYPE_MEM6", ":", "return", "OP_TYPE_MEM6", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Return", "operand", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "of", "INSN", ",", "if", "it", "is", "a", "MEM", ",", "or", "NULL", "overwise", "." ]

[ "m68k" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "Mono", "&&", "IsWin64", ")", "CC", "=", "CallingConv", "::", "Win64", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_RegMask", ";", "return", "CSR_64_AllRegs_NoSSE_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_RegMask", ":", "CSR_64_SwiftError_RegMask", ";", "return", "IsWin64", "?", "CSR_Win64_RegMask", ":", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "aarch64_final_eh_return_addr", "(", "void", ")", "{", "HOST_WIDE_INT", "fp_offset", ";", "aarch64_layout_frame", "(", ")", ";", "fp_offset", "=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "-", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", ";", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "LR_REGNUM", "]", "<", "0", ")", "return", "gen_rtx_REG", "(", "DImode", ",", "LR_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "fp_offset", ")", "return", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "UNITS_PER_WORD", ")", ")", ";", "else", "return", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ")", ";", "}", "return", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "fp_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "saved_regs_size", "-", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "place", "to", "copy", "the", "exception", "unwinding", "return", "address", "to", ".", "This", "will", "probably", "be", "a", "stack", "slot", ",", "but", "could", "(", "in", "theory", "be", "the", "return", "register", ")", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "AArch64FI", "=", "F", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "MSP430", "\"MSP430 Branch Selector\"" ]

[]

[ "<s>", "int", "avr_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "if", "(", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "&&", "(", "old_reg", "==", "REG_Y", "||", "old_reg", "==", "REG_Y", "+", "1", "||", "new_reg", "==", "REG_Y", "||", "new_reg", "==", "REG_Y", "+", "1", ")", ")", "{", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

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

[]

[ "<s>", "static", "bool", "s390_keep_leaf_when_profiled", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "We", "call", "mcount", "before", "the", "function", "prologue", ".", "So", "a", "profiled", "leaf", "function", "should", "stay", "a", "leaf", "function", "." ]

[ "s390" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "VETargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "case", "'r'", ":", "RC", "=", "&", "VE", "::", "I64RegClass", ";", "break", ";", "case", "'v'", ":", "RC", "=", "&", "VE", "::", "V64RegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "0U", ",", "RC", ")", ";", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "1", "0", "VE::I64RegClass", "VE::V64RegClass", "0U" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "arm_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "(", "machine_function", "*", ")", "ggc_alloc_cleared", "(", "sizeof", "(", "machine_function", ")", ")", ";", "machine", "->", "func_type", "=", "ARM_FT_UNKNOWN", ";", "return", "machine", ";", "}", "</s>" ]

[ "Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]

[ "arm" ]

[]

[ "<s>", "Register", "M68kIncomingValueHandler", "::", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "bool", "IsImmutable", "=", "!", "Flags", ".", "isByVal", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "IsImmutable", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "llvm", "::", "LLT", "FramePtr", "=", "LLT", "::", "pointer", "(", "0", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getDataLayout", "(", ")", ".", "getPointerSizeInBits", "(", ")", ")", ";", "MachineInstrBuilder", "AddrReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "FramePtr", ",", "FI", ")", ";", "StackUsed", "=", "std", "::", "max", "(", "StackUsed", ",", "Size", "+", "Offset", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "M68k", "M68k", "ISD::ArgFlagsTy", "0", "0" ]

[]

[ "<s>", "bool", "SparcInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "if", "(", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isCondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "LastInst", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "*", "SecondLastInst", "=", "&", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "AllowModify", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "while", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", ")", "{", "LastInst", "->", "eraseFromParent", "(", ")", ";", "LastInst", "=", "SecondLastInst", ";", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "{", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "}", "}", "}", "if", "(", "SecondLastInst", "&&", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "true", ";", "if", "(", "isCondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "SecondLastInst", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

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

[]

[ "<s>", "const", "char", "*", "pa_output_mod_insn", "(", "int", "unsignedp", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "unsignedp", ")", "{", "import_milli", "(", "remU", ")", ";", "return", "pa_output_millicode_call", "(", "insn", ",", "gen_rtx_SYMBOL_REF", "(", "SImode", ",", "\"$$remU\"", ")", ")", ";", "}", "else", "{", "import_milli", "(", "remI", ")", ";", "return", "pa_output_millicode_call", "(", "insn", ",", "gen_rtx_SYMBOL_REF", "(", "SImode", ",", "\"$$remI\"", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "$", "$", "rem", "millicode", "to", "do", "mod", "." ]

[ "pa", "\"$$remU\"", "\"$$remI\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "static", "machine_mode", "avr_addr_space_address_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addrspace", "[", "as", "]", ".", "pointer_size", "==", "3", "?", "PSImode", ":", "HImode", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_ADDRESS_MODE", "'", "." ]

[ "avr", "3" ]

[]

[ "<s>", "int", "RISCVFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "RISCV", "::", "X2", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "else", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "RISCV", "RISCV", "RISCV", "0", "1", "0", "1", "RISCV::X2" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "PhysReg", "==", "RISCV", "::", "X0", "||", "PhysReg", "==", "RISCV", "::", "C0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "RISCV", "RISCV", "RISCV::X0", "RISCV::C0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", "Align", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "{", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "*", "Fast", "=", "true", ";", "break", ";", "case", "128", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", ";", "break", ";", "case", "256", ":", "*", "Fast", "=", "!", "Subtarget", ".", "isUnalignedMem32Slow", "(", ")", ";", "break", ";", "}", "}", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MONonTemporal", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "!", "!", "(", "Flags", "&", "MachineMemOperand", "::", "MOLoad", ")", ")", "return", "(", "Align", "<", "16", "||", "!", "Subtarget", ".", "hasSSE41", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "128", "256", "16" ]

[]

[ "<s>", "MCSymbol", "*", "OR1KMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "void", "mips_74k_agen_reorder", "(", "rtx_insn", "*", "*", "ready", ",", "int", "nready", ")", "{", "int", "i", ";", "int", "store_pos", ",", "load_pos", ";", "store_pos", "=", "-", "1", ";", "load_pos", "=", "-", "1", ";", "for", "(", "i", "=", "nready", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "rtx_insn", "*", "insn", "=", "ready", "[", "i", "]", ";", "if", "(", "USEFUL_INSN_P", "(", "insn", ")", ")", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_STORE", ":", "if", "(", "store_pos", "==", "-", "1", ")", "store_pos", "=", "i", ";", "break", ";", "case", "TYPE_LOAD", ":", "if", "(", "load_pos", "==", "-", "1", ")", "load_pos", "=", "i", ";", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "load_pos", "==", "-", "1", "||", "store_pos", "==", "-", "1", ")", "return", ";", "switch", "(", "mips_last_74k_agen_insn", ")", "{", "case", "TYPE_UNKNOWN", ":", "case", "TYPE_LOAD", ":", "mips_maybe_swap_ready", "(", "ready", ",", "load_pos", ",", "store_pos", ",", "4", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "mips_maybe_swap_ready", "(", "ready", ",", "store_pos", ",", "load_pos", ",", "4", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "A", "TUNE_74K", "helper", "function", ".", "The", "74K", "AGEN", "pipeline", "likes", "multiple", "loads", "to", "be", "grouped", "together", ",", "and", "multiple", "stores", "to", "be", "grouped", "together", ".", "Swap", "things", "around", "in", "the", "ready", "queue", "to", "make", "this", "happen", "." ]

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

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "M88k" ]

[]

[ "<s>", "void", "PPCMIPeephole", "::", "initialize", "(", "MachineFunction", "&", "MFParm", ")", "{", "MF", "=", "&", "MFParm", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** PowerPC MI peephole pass ***\\n\\n\"", ")", ";", "DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "PowerPC", "PPC", "PPC", "\"*** PowerPC MI peephole pass ***\\n\\n\"" ]

[]

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

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

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

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Asm", ",", "Fixup", ",", "Target", ",", "Value", ",", "IsResolved", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "Endian", "==", "support", "::", "big", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "support::big", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "LDW_RI", ")", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::LDW_RI", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "MMIXMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "\"Unhandled expression!\"", "0" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "isInt", "<", "15", ">", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ")", "&&", "!", "MFI", "->", "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", "." ]

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

[]

[ "<s>", "const", "RegisterBank", "&", "ARMRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "ARM", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "GPRRegClassID", ":", "case", "GPRnopcRegClassID", ":", "case", "tGPR_and_tcGPRRegClassID", ":", "case", "tGPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "GPRRegBankID", ")", ";", "case", "SPR_8RegClassID", ":", "case", "SPRRegClassID", ":", "case", "DPR_8RegClassID", ":", "case", "DPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "FPRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported register kind\"", ")", ";", "}", "llvm_unreachable", "(", "\"Switch should handle all register classes\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegBankID", "ARM::FPRRegBankID", "\"Unsupported register kind\"", "\"Switch should handle all register classes\"" ]

[]

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

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

[ "XCore", "XCore", "XCore::STWFI", "0" ]

[]

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

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

[ "ARC", "ARC" ]

[]

[ "<s>", "void", "LC3bMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "LC3b", "LC3b" ]

[]

[ "<s>", "static", "void", "ia64_init_dfa_pre_cycle_insn", "(", "void", ")", "{", "if", "(", "temp_dfa_state", "==", "NULL", ")", "{", "dfa_state_size", "=", "state_size", "(", ")", ";", "temp_dfa_state", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "prev_cycle_state", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "}", "dfa_pre_cycle_insn", "=", "make_insn_raw", "(", "gen_pre_cycle", "(", ")", ")", ";", "SET_PREV_INSN", "(", "dfa_pre_cycle_insn", ")", "=", "SET_NEXT_INSN", "(", "dfa_pre_cycle_insn", ")", "=", "NULL_RTX", ";", "recog_memoized", "(", "dfa_pre_cycle_insn", ")", ";", "dfa_stop_insn", "=", "make_insn_raw", "(", "gen_insn_group_barrier", "(", "GEN_INT", "(", "3", ")", ")", ")", ";", "SET_PREV_INSN", "(", "dfa_stop_insn", ")", "=", "SET_NEXT_INSN", "(", "dfa_stop_insn", ")", "=", "NULL_RTX", ";", "recog_memoized", "(", "dfa_stop_insn", ")", ";", "}", "</s>" ]

[ "The", "following", "function", "initiates", "variable", "`", "dfa_pre_cycle_insn", "'", "." ]

[ "ia64", "3" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "return", "false", ";", "}", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "EntryMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "EntryMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "Register", "SPCopy", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AVR", "::", "DREGSRegClass", ")", ";", "BuildMI", "(", "EntryMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "COPY", ")", ",", "SPCopy", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", "&&", "MBB", ".", "back", "(", ")", ".", "isReturn", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "COPY", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "SPCopy", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR::DREGSRegClass", "AVR::COPY", "AVR::SP", "AVR::COPY", "AVR::SP" ]

[]

[ "<s>", "unsigned", "AGCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "return", "0", ";", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "0", "\"Unhandled expression!\"", "0" ]

[]

[ "<s>", "rtx", "s390_emit_compare", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "s390_select_ccmode", "(", "code", ",", "op0", ",", "op1", ")", ";", "rtx", "cc", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_CC", ")", "{", "gcc_assert", "(", "s390_cc_modes_compatible", "(", "GET_MODE", "(", "op0", ")", ",", "mode", ")", "==", "GET_MODE", "(", "op0", ")", ")", ";", "cc", "=", "op0", ";", "}", "else", "{", "cc", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc", ",", "gen_rtx_COMPARE", "(", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "compare", "instruction", "suitable", "to", "implement", "the", "comparison", "OP0", "CODE", "OP1", ".", "Return", "the", "correct", "condition", "RTL", "to", "be", "placed", "in", "the", "IF_THEN_ELSE", "of", "the", "conditional", "branch", "testing", "the", "result", "." ]

[ "s390" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2LDRi12", "0", "ARM" ]

[]

[ "<s>", "rtx", "or1k_initial_frame_addr", "(", ")", "{", "crtl", "->", "accesses_prior_frames", "=", "1", ";", "return", "arg_pointer_rtx", ";", "}", "</s>" ]

[ "Worker", "for", "INITIAL_FRAME_ADDRESS_RTX", ".", "Returns", "the", "RTX", "representing", "the", "address", "of", "the", "initial", "stack", "frame", "." ]

[ "or1k", "1" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "return", "isMEMrr", "(", ")", "||", "isMEMri", "(", ")", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "Sparc" ]

[]

[ "<s>", "static", "bool", "riscv_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "nregs", "=", "riscv_hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "!", "GP_REG_P", "(", "regno", "+", "nregs", "-", "1", ")", ")", "return", "false", ";", "}", "else", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "!", "FP_REG_P", "(", "regno", "+", "nregs", "-", "1", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_COMPLEX_FLOAT", ")", "return", "false", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ">", "UNITS_PER_FP_REG", "||", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ">", "UNITS_PER_FP_ARG", ")", ")", "return", "false", ";", "}", "else", "if", "(", "V_REG_P", "(", "regno", ")", ")", "{", "if", "(", "!", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "!", "V_REG_P", "(", "regno", "+", "nregs", "-", "1", ")", ")", "return", "false", ";", "int", "lmul", "=", "1", ";", "if", "(", "known_gt", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_V_REG", ")", ")", "lmul", "=", "exact_div", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_V_REG", ")", ".", "to_constant", "(", ")", ";", "if", "(", "lmul", "!=", "1", ")", "return", "(", "(", "regno", "%", "lmul", ")", "==", "0", ")", ";", "}", "else", "if", "(", "regno", "==", "VL_REGNUM", "||", "regno", "==", "VTYPE_REGNUM", ")", "return", "true", ";", "else", "return", "false", ";", "for", "(", "unsigned", "i", "=", "1", ";", "i", "<", "nregs", ";", "i", "++", ")", "if", "(", "call_used_or_fixed_reg_p", "(", "regno", ")", "!=", "call_used_or_fixed_reg_p", "(", "regno", "+", "i", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_ZDINX", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "==", "GET_MODE_SIZE", "(", "DFmode", ")", ")", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "riscv", "1", "1", "1", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "AVRAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "AVR::R31R30", "\"Z\"", "AVR::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "static", "SDValue", "WidenVector", "(", "SDValue", "V64Reg", ",", "SelectionDAG", "&", "DAG", ")", "{", "EVT", "VT", "=", "V64Reg", ".", "getValueType", "(", ")", ";", "unsigned", "NarrowSize", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltTy", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "MVT", "WideTy", "=", "MVT", "::", "getVectorVT", "(", "EltTy", ",", "2", "*", "NarrowSize", ")", ";", "SDLoc", "DL", "(", "V64Reg", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "DL", ",", "WideTy", ",", "DAG", ".", "getUNDEF", "(", "WideTy", ")", ",", "V64Reg", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "Widen", "the", "vector", "up", "to", "the", "next", "power", "of", "two", "using", "INSERT_SUBVECTOR", "." ]

[ "ARM64", "MVT::getVectorVT", "2", "ISD::INSERT_SUBVECTOR", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "AArch64MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetGlobalAddressSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"unknown operand type\"" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildAddiuSpImm", "(", "MBB", ",", "I", ",", "Amount", ")", ";", "else", "adjustStackPtrBigUnrestricted", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

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

[]

[ "<s>", "void", "altivec_expand_vec_perm_le", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "notx", ",", "iorx", ",", "unspec", ";", "rtx", "target", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "sel", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", "=", "target", ";", "rtx", "norreg", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "!", "REG_P", "(", "op1", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "REG_P", "(", "sel", ")", ")", "sel", "=", "force_reg", "(", "V16QImode", ",", "sel", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "sel", ")", ";", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "norreg", ",", "iorx", ")", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op0", ",", "norreg", ")", ",", "UNSPEC_VPERM", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "{", "emit_move_insn", "(", "tmp", ",", "unspec", ")", ";", "unspec", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Similarly", "to", "altivec_expand_vec_perm_const_le", ",", "we", "must", "adjust", "the", "permute", "control", "vector", ".", "But", "here", "it", "'s", "not", "a", "constant", ",", "so", "we", "must", "generate", "a", "vector", "NAND", "or", "NOR", "to", "do", "the", "adjustment", "." ]

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

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "static", "void", "arm_emit_multi_reg_pop", "(", "unsigned", "long", "saved_regs_mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "tmp", ",", "reg", ";", "bool", "return_in_pc", "=", "saved_regs_mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ";", "int", "offset_adj", ";", "int", "emit_update", ";", "offset_adj", "=", "return_in_pc", "?", "1", ":", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "emit_update", "=", "(", "saved_regs_mask", "&", "(", "1", "<<", "SP_REGNUM", ")", ")", "?", "0", ":", "1", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "emit_update", "+", "offset_adj", ")", ")", ";", "if", "(", "return_in_pc", ")", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "ret_rtx", ";", "if", "(", "emit_update", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "offset_adj", ")", "=", "tmp", ";", "}", "for", "(", "j", "=", "0", ",", "i", "=", "0", ";", "j", "<", "num_regs", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "rtx", "dwarf_reg", "=", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", "&&", "i", "==", "IP_REGNUM", ")", "dwarf_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "RA_AUTH_CODE", ")", ";", "if", "(", "(", "num_regs", "==", "1", ")", "&&", "emit_update", "&&", "!", "return_in_pc", ")", "{", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "tmp", "=", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "tmp", ")", ")", ";", "REG_NOTES", "(", "tmp", ")", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "dwarf_reg", ",", "dwarf", ")", ";", "return", ";", "}", "tmp", "=", "gen_rtx_SET", "(", "reg", ",", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "+", "emit_update", "+", "offset_adj", ")", "=", "tmp", ";", "if", "(", "i", "!=", "PC_REGNUM", ")", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "dwarf_reg", ",", "dwarf", ")", ";", "j", "++", ";", "}", "if", "(", "return_in_pc", ")", "par", "=", "emit_jump_insn", "(", "par", ")", ";", "else", "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "dwarf", ";", "if", "(", "!", "return_in_pc", ")", "arm_add_cfa_adjust_cfa_note", "(", "par", ",", "UNITS_PER_WORD", "*", "num_regs", ",", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "pattern", "that", "we", "will", "recognize", "as", "a", "pop_multi", ".", "SAVED_REGS_MASK", "shows", "which", "registers", "need", "to", "be", "restored", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

[ "arm", "0", "1", "1", "0", "0", "1", "16", "1", "0", "1", "0", "0", "4", "1", "0", "0", "0", "1", "1", "4", "1", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "int", "Begin", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "Begin", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "1", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_64RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "2", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_96RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "3", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_128RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "7", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_256RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "15", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_512RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "R600", "SI", "1", "0", "1", "0", "2", "0", "3", "0", "7", "0", "15" ]

[]

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

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

[ "R600" ]

[]

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

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

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

[]

[ "<s>", "bool", "SparcDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectADDRrr", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectADDRri", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "return", "31", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "AArch64", "32", "0", "31" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR6", "||", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "CurSlots", "==", "6", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "CurGroup", ".", "push_back", "(", "nullptr", ")", ";", "++", "CurSlots", ";", "}", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR6", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR8", "6", "0" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "STI", ".", "getFramePointerReg", "(", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasD32", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "ZR", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass", "ARM::ZR" ]

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "PIC16TargetLowering", "*", "PTLI", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movwf", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "1", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "{", "unsigned", "opcode", "=", "(", "SrcReg", "==", "PIC16", "::", "FSR0", ")", "?", "PIC16", "::", "save_fsr0", ":", "PIC16", "::", "save_fsr1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "3", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16", "PIC16::GPRRegisterClass", "PIC16::movwf", "1", "1", "PIC16::FSR16RegisterClass", "PIC16::FSR0", "PIC16::save_fsr0", "PIC16::save_fsr1", "3", "1", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "bool", "aarch64_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "is", "thread", "local" ]

[ "aarch64", "0" ]

[]

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

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

[ "VE", "MVT::i32" ]

[]

[ "<s>", "bool", "LC2200AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "LC2200", "LC2200" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getMatchingSuperRegClass", "(", "const", "TargetRegisterClass", "*", "A", ",", "const", "TargetRegisterClass", "*", "B", ",", "unsigned", "Idx", ")", "const", "{", "return", "A", ";", "}", "</s>" ]

[ "getMatchingSuperRegClass", "-", "Return", "a", "subclass", "of", "the", "specified", "register", "class", "A", "so", "that", "each", "register", "in", "it", "has", "a", "sub-register", "of", "the", "specified", "sub-register", "index", "which", "is", "in", "the", "specified", "register", "class", "B", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "CSKYRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "Mod", "=", "&", "M", ";", "DL", "=", "&", "Mod", "->", "getDataLayout", "(", ")", ";", "MDBuilder", "MDB", "(", "Mod", "->", "getContext", "(", ")", ")", ";", "MaxWorkGroupSizeRange", "=", "MDB", ".", "createRange", "(", "APInt", "(", "32", ",", "0", ")", ",", "APInt", "(", "32", ",", "2048", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU", "32", "0", "32", "2048" ]

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMappings", "X86RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "{", "unsigned", "Size", "=", "getSizeInBits", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "TRI", ")", ";", "if", "(", "Size", "!=", "32", "&&", "Size", "!=", "64", ")", "break", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "4", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "true", ",", "OpRegBankIdx", ")", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "8", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "if", "(", "!", "getInstrValueMapping", "(", "MI", ",", "OpRegBankIdx", ",", "OpdsMapping", ")", ")", "break", ";", "RegisterBankInfo", "::", "InstructionMapping", "Mapping", "=", "InstructionMapping", "{", "1", ",", "1", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "NumOperands", "}", ";", "InstructionMappings", "AltMappings", ";", "AltMappings", ".", "emplace_back", "(", "std", "::", "move", "(", "Mapping", ")", ")", ";", "return", "AltMappings", ";", "}", "default", ":", "break", ";", "}", "return", "RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "MI", ")", ";", "}", "</s>" ]

[ "Get", "the", "alternative", "mappings", "for", "MI", "." ]

[ "X86", "X86", "0", "32", "64", "4", "8", "1", "1" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SystemZ", "::", "GR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "KillSrc", ")", ";", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "KillSrc", ")", ";", "return", ";", "}", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "emitGRX32Move", "(", "MBB", ",", "MBBI", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "SystemZ", "::", "LR", ",", "32", ",", "KillSrc", ")", ";", "return", ";", "}", "unsigned", "Opcode", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LGR", ";", "else", "if", "(", "SystemZ", "::", "FP32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "STI", ".", "hasVector", "(", ")", "?", "SystemZ", "::", "LDR32", ":", "SystemZ", "::", "LER", ";", "else", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LDR", ";", "else", "if", "(", "SystemZ", "::", "FP128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LXR", ";", "else", "if", "(", "SystemZ", "::", "VR32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR32", ";", "else", "if", "(", "SystemZ", "::", "VR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR64", ";", "else", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR", ";", "else", "if", "(", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "CPYA", ";", "else", "if", "(", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "DestReg", ")", "&&", "SystemZ", "::", "GR32BitRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "SAR", ";", "else", "if", "(", "SystemZ", "::", "GR32BitRegClass", ".", "contains", "(", "DestReg", ")", "&&", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "EAR", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::GR128BitRegClass", "SystemZ::subreg_h64", "SystemZ::subreg_h64", "SystemZ::subreg_l64", "SystemZ::subreg_l64", "SystemZ::GRX32BitRegClass", "SystemZ::LR", "32", "SystemZ::GR64BitRegClass", "SystemZ::LGR", "SystemZ::FP32BitRegClass", "SystemZ::LDR32", "SystemZ::LER", "SystemZ::FP64BitRegClass", "SystemZ::LDR", "SystemZ::FP128BitRegClass", "SystemZ::LXR", "SystemZ::VR32BitRegClass", "SystemZ::VLR32", "SystemZ::VR64BitRegClass", "SystemZ::VLR64", "SystemZ::VR128BitRegClass", "SystemZ::VLR", "SystemZ::AR32BitRegClass", "SystemZ::CPYA", "SystemZ::AR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::SAR", "SystemZ::GR32BitRegClass", "SystemZ::AR32BitRegClass", "SystemZ::EAR", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "const", "char", "*", "csky_output_ck801_move", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "struct", "csky_address", "op1", ";", "if", "(", "REG_P", "(", "dst", ")", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "\"mov\\t%0, %1\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "decompose_csky_address", "(", "XEXP", "(", "src", ",", "0", ")", ",", "&", "op1", ")", ";", "if", "(", "op1", ".", "label", ")", "return", "\"lrw\\t%0, %1\"", ";", "else", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "E_HImode", ":", "return", "\"ld.h\\t%0, %1\"", ";", "case", "E_QImode", ":", "return", "\"ld.b\\t%0, %1\"", ";", "case", "E_SFmode", ":", "case", "E_SImode", ":", "return", "\"ld.w\\t%0, %1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "if", "(", "REGNO", "(", "dst", ")", ">", "7", ")", "return", "\"lrw\\t%0, %x1\\t\"", ";", "else", "if", "(", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", "+", "1", ")", ")", "return", "\"movi\\t%0, %1\"", ";", "else", "if", "(", "CSKY_CONST_OK_FOR_T", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"#\"", ";", "else", "if", "(", "csky_shifted_imm8_constant", "(", "INTVAL", "(", "src", ")", ",", "NULL", ",", "NULL", ")", ")", "return", "\"#\"", ";", "else", "return", "\"lrw\\t%0, %x1\\t\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "src", ")", "==", "SFmode", ")", "{", "const", "REAL_VALUE_TYPE", "*", "d", ";", "long", "l", ";", "d", "=", "CONST_DOUBLE_REAL_VALUE", "(", "src", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "d", ",", "l", ")", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "l", ")", ";", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "src", ")", "+", "1", ")", ")", "return", "\"movi\\t%0, %1\"", ";", "else", "return", "\"lrw\\t%0, %x1\\t\"", ";", "}", "else", "if", "(", "TARGET_ANCHOR", "&&", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "SYMBOL_REF_FUNCTION_P", "(", "src", ")", ")", "return", "\"lrw\\t%0, %1@BTEXT\"", ";", "else", "return", "\"lrw\\t%0, %1@BDATA\"", ";", "}", "else", "return", "\"lrw\\t%0, %1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "E_HImode", ":", "return", "\"st.h\\t%1, %0\"", ";", "case", "E_QImode", ":", "return", "\"st.b\\t%1, %0\"", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "return", "\"st.w\\t%1, %0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

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

[ "csky", "0", "1", "\"mov\\t%0, %1\"", "0", "\"lrw\\t%0, %1\"", "\"ld.h\\t%0, %1\"", "\"ld.b\\t%0, %1\"", "\"ld.w\\t%0, %1\"", "7", "\"lrw\\t%0, %x1\\t\"", "1", "\"movi\\t%0, %1\"", "\"#\"", "\"#\"", "\"lrw\\t%0, %x1\\t\"", "1", "1", "1", "\"movi\\t%0, %1\"", "\"lrw\\t%0, %x1\\t\"", "\"lrw\\t%0, %1@BTEXT\"", "\"lrw\\t%0, %1@BDATA\"", "\"lrw\\t%0, %1\"", "\"st.h\\t%1, %0\"", "\"st.b\\t%1, %0\"", "\"st.w\\t%1, %0\"" ]

[]

[ "<s>", "static", "bool", "frv_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "mode1", "==", "mode2", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "frv" ]

[]

[ "<s>", "static", "rtx", "frv_expand_mwtacc_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "0", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "MWTACC", "and", "MWTACCG", ".", "These", "builtins", "take", "an", "accumulator", "or", "accumulator", "guard", "as", "their", "first", "argument", "and", "an", "SImode", "value", "as", "their", "second", "." ]

[ "frv", "0", "1", "0", "1" ]

[]