Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly" ]

[]

[ "<s>", "static", "char", "*", "ix86_offload_options", "(", "void", ")", "{", "if", "(", "TARGET_LP64", ")", "return", "xstrdup", "(", "\"-foffload-abi=lp64\"", ")", ";", "return", "xstrdup", "(", "\"-foffload-abi=ilp32\"", ")", ";", "}", "</s>" ]

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

[ "i386", "\"-foffload-abi=lp64\"", "\"-foffload-abi=ilp32\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Expand special instructions pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Expand special instructions pass\"" ]

[]

[ "<s>", "static", "void", "sh_trampoline_init", "(", "rtx", "tramp_mem", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "tramp_mem", ",", "0", ")", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "rtx", "a", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "tramp_mem", ",", "0", ")", ",", "8", ")", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "0", ",", "a", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "4", ",", "sh_get_fdpic_reg_initial_val", "(", ")", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "8", ",", "0xd302", ",", "0xd203", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "12", ",", "0x6122", ",", "0x5c21", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "16", ",", "0x412b", ",", "0x0009", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "20", ",", "cxt", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "24", ",", "fnaddr", ")", ";", "}", "else", "{", "sh_emit_storehi", "(", "tramp_mem", ",", "0", ",", "0xd202", ",", "0xd301", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "4", ",", "0x422b", ",", "0x0009", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "8", ",", "cxt", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "12", ",", "fnaddr", ")", ";", "}", "if", "(", "TARGET_HARD_SH4", ")", "{", "if", "(", "!", "TARGET_INLINE_IC_INVALIDATE", "||", "(", "!", "(", "TARGET_SH4A", "||", "TARGET_SH4_300", ")", "&&", "TARGET_USERMODE", ")", ")", "emit_library_call", "(", "function_symbol", "(", "NULL", ",", "\"__ic_invalidate\"", ",", "FUNCTION_ORDINARY", ")", ".", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "tramp", ",", "SImode", ")", ";", "else", "emit_insn", "(", "gen_ic_invalidate_line", "(", "tramp", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "sh", "0", "0", "0", "8", "0", "4", "8", "0xd302", "0xd203", "12", "0x6122", "0x5c21", "16", "0x412b", "0x0009", "20", "24", "0", "0xd202", "0xd301", "4", "0x422b", "0x0009", "8", "12", "\"__ic_invalidate\"" ]

[]

[ "<s>", "MachinePointerInfo", "MipsFunctionInfo", "::", "callPtrInfo", "(", "const", "GlobalValue", "*", "GV", ")", "{", "return", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getGlobalValueCallEntry", "(", "GV", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AI", "->", "getValOperand", "(", ")", ")", ")", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Or", "&&", "C", "->", "isZero", "(", ")", "&&", "AI", "->", "use_empty", "(", ")", ")", "return", "nullptr", ";", "IRBuilder", "<", ">", "Builder", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SSID", "=", "AI", "->", "getSyncScopeID", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "SingleThread", ")", "return", "nullptr", ";", "if", "(", "!", "Subtarget", ".", "hasMFence", "(", ")", ")", "return", "nullptr", ";", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ",", "{", "}", ")", ";", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "AI", "->", "getType", "(", ")", ",", "AI", "->", "getPointerOperand", "(", ")", ",", "AI", "->", "getAlign", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SSID", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SISubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "unsigned", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "BaseReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "0", "AMDGPU::V_MOV_B32_e32", "AMDGPU::SReg_64RegClass", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::S_MOV_B32", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableRedZone", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "unsigned", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";", "return", "!", "(", "MFI", ".", "hasCalls", "(", ")", "||", "hasFP", "(", "MF", ")", "||", "NumBytes", ">", "128", "||", "getSVEStackSize", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "Can", "this", "function", "use", "the", "red", "zone", "for", "local", "allocations", "." ]

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

[]

[ "<s>", "void", "sh_mark_label", "(", "rtx", "address", ",", "int", "nuses", ")", "{", "if", "(", "GOTOFF_P", "(", "address", ")", ")", "{", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "address", ")", "==", "PLUS", ")", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "address", "=", "XVECEXP", "(", "address", ",", "0", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "address", ")", "==", "LABEL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "address", ",", "0", ")", ")", "==", "CODE_LABEL", ")", "LABEL_NUSES", "(", "XEXP", "(", "address", ",", "0", ")", ")", "+=", "nuses", ";", "}", "</s>" ]

[ "If", "ADDRESS", "refers", "to", "a", "CODE_LABEL", ",", "add", "NUSES", "to", "the", "number", "of", "times", "that", "label", "is", "used", "." ]

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

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "SHUXI" ]

[]

[ "<s>", "int", "includes_rldicr_lshift_p", "(", "rtx", "shiftop", ",", "rtx", "andop", ")", "{", "if", "(", "GET_CODE", "(", "andop", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "c", ",", "lsb", ",", "shift_mask", ";", "shift_mask", "=", "~", "0", ";", "shift_mask", "<<=", "INTVAL", "(", "shiftop", ")", ";", "c", "=", "INTVAL", "(", "andop", ")", ";", "lsb", "=", "c", "&", "-", "c", ";", "if", "(", "(", "lsb", "&", "shift_mask", ")", "==", "0", ")", "return", "0", ";", "return", "c", "==", "-", "lsb", "&&", "lsb", "!=", "1", ";", "}", "else", "if", "(", "GET_CODE", "(", "andop", ")", "==", "CONST_DOUBLE", "&&", "(", "GET_MODE", "(", "andop", ")", "==", "VOIDmode", "||", "GET_MODE", "(", "andop", ")", "==", "DImode", ")", ")", "{", "HOST_WIDE_INT", "low", ",", "lsb", ",", "shift_mask_low", ";", "low", "=", "CONST_DOUBLE_LOW", "(", "andop", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", "<", "64", ")", "{", "HOST_WIDE_INT", "high", ",", "shift_mask_high", ";", "high", "=", "CONST_DOUBLE_HIGH", "(", "andop", ")", ";", "if", "(", "low", "==", "0", ")", "{", "shift_mask_high", "=", "~", "0", ";", "if", "(", "INTVAL", "(", "shiftop", ")", ">", "32", ")", "shift_mask_high", "<<=", "INTVAL", "(", "shiftop", ")", "-", "32", ";", "lsb", "=", "high", "&", "-", "high", ";", "if", "(", "(", "lsb", "&", "shift_mask_high", ")", "==", "0", ")", "return", "0", ";", "return", "high", "==", "-", "lsb", ";", "}", "if", "(", "high", "!=", "~", "0", ")", "return", "0", ";", "}", "shift_mask_low", "=", "~", "0", ";", "shift_mask_low", "<<=", "INTVAL", "(", "shiftop", ")", ";", "lsb", "=", "low", "&", "-", "low", ";", "if", "(", "(", "lsb", "&", "shift_mask_low", ")", "==", "0", ")", "return", "0", ";", "return", "low", "==", "-", "lsb", "&&", "lsb", "!=", "1", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "ANDOP", "is", "a", "mask", "suitable", "for", "use", "with", "an", "rldicr", "insn", "to", "perform", "a", "left", "shift", ".", "It", "must", "have", "SHIFTOP", "or", "more", "least", "significant", "0", "'s", ",", "with", "the", "remainder", "of", "the", "word", "1", "'s", "." ]

[ "rs6000", "0", "0", "0", "1", "64", "0", "0", "32", "32", "0", "0", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "bool", "pa_callee_copies", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "TARGET_CALLER_COPIES", ";", "}", "</s>" ]

[ "Implement", "TARGET_CALLEE_COPIES", ".", "The", "callee", "is", "responsible", "for", "copying", "arguments", "passed", "by", "hidden", "reference", "in", "the", "32-bit", "HP", "runtime", ".", "Users", "can", "override", "this", "behavior", "for", "better", "compatibility", "with", "openmp", "at", "the", "risk", "of", "library", "incompatibilities", ".", "Arguments", "are", "always", "passed", "by", "value", "in", "the", "64-bit", "HP", "runtime", "." ]

[ "pa" ]

[]

[ "<s>", "bool", "GCNRegBankReassign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasRegisterBanking", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "LRM", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "MFI", "->", "getOccupancy", "(", ")", ";", "MaxNumVGPRs", "=", "ST", "->", "getMaxNumVGPRs", "(", "MF", ")", ";", "MaxNumSGPRs", "=", "ST", "->", "getMaxNumSGPRs", "(", "MF", ")", ";", "MaxNumVGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "MaxNumVGPRs", ")", ";", "MaxNumSGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "MaxNumSGPRs", ")", ";", "CSRegs", "=", "MRI", "->", "getCalleeSavedRegs", "(", ")", ";", "RegsUsed", ".", "resize", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", "+", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "SGPR_NULL", ")", "/", "2", "+", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== RegBanks reassign analysis on function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "unsigned", "StallCycles", "=", "collectCandidates", "(", "MF", ")", ";", "NumStallsDetected", "+=", "StallCycles", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== \"", "<<", "StallCycles", "<<", "\" stall cycles detected in \"", "\"function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LLVM_DEBUG", "(", "Candidates", ".", "dump", "(", "this", ")", ")", ";", "unsigned", "CyclesSaved", "=", "0", ";", "while", "(", "!", "Candidates", ".", "empty", "(", ")", ")", "{", "Candidate", "C", "=", "Candidates", ".", "back", "(", ")", ";", "unsigned", "LocalCyclesSaved", "=", "tryReassign", "(", "C", ")", ";", "CyclesSaved", "+=", "LocalCyclesSaved", ";", "if", "(", "VerifyStallCycles", ">", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "Candidates", ".", "pop_back", "(", ")", ";", "if", "(", "LocalCyclesSaved", ")", "{", "removeCandidates", "(", "C", ".", "Reg", ")", ";", "computeStallCycles", "(", "C", ".", "Reg", ",", "AMDGPU", "::", "NoRegister", ",", "0", ",", "-", "1", ",", "true", ")", ";", "LLVM_DEBUG", "(", "Candidates", ".", "dump", "(", "this", ")", ")", ";", "}", "}", "NumStallsRecovered", "+=", "CyclesSaved", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== After the pass \"", "<<", "CyclesSaved", "<<", "\" cycles saved in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "clear", "(", ")", ";", "if", "(", "VerifyStallCycles", "==", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "RegsUsed", ".", "clear", "(", ")", ";", "return", "CyclesSaved", ">", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_NULL", "2", "1", "\"=== RegBanks reassign analysis on function \"", "\"=== \"", "\" stall cycles detected in \"", "\"function \"", "0", "1", "\"RegBank reassign stall cycles verification failed.\"", "AMDGPU::NoRegister", "0", "1", "\"=== After the pass \"", "\" cycles saved in function \"", "1", "\"RegBank reassign stall cycles verification failed.\"", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "unsigned", "Opcode", "=", "getSGPRSpillSaveOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR0" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode!\"", ")", ";", "case", "RISCV", "::", "BEQ", ":", "case", "RISCV", "::", "BNE", ":", "case", "RISCV", "::", "BLT", ":", "case", "RISCV", "::", "BGE", ":", "case", "RISCV", "::", "BLTU", ":", "case", "RISCV", "::", "BGEU", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "RISCV", "::", "JAL", ":", "case", "RISCV", "::", "PseudoBR", ":", "return", "isIntN", "(", "21", ",", "BrOffset", ")", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "RISCV", "RISCV", "\"Unexpected opcode!\"", "RISCV::BEQ", "RISCV::BNE", "RISCV::BLT", "RISCV::BGE", "RISCV::BLTU", "RISCV::BGEU", "13", "RISCV::JAL", "RISCV::PseudoBR", "21" ]

[]

[ "<s>", "static", "int", "s390_split_branches", "(", "void", ")", "{", "rtx", "temp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "int", "new_literal", "=", "0", ",", "ret", ";", "rtx_insn", "*", "insn", ";", "rtx", "pat", ",", "target", ";", "rtx", "*", "label", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "tablejump_p", "(", "insn", ",", "NULL", ",", "NULL", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "SET_DEST", "(", "pat", ")", "!=", "pc_rtx", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "LABEL_REF", ")", "{", "label", "=", "&", "SET_SRC", "(", "pat", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "IF_THEN_ELSE", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ")", "==", "LABEL_REF", ")", "label", "=", "&", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "2", ")", ")", "==", "LABEL_REF", ")", "label", "=", "&", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "2", ")", ";", "else", "continue", ";", "}", "else", "continue", ";", "if", "(", "get_attr_length", "(", "insn", ")", "<=", "4", ")", "continue", ";", "cfun_frame_layout", ".", "save_return_addr_p", "=", "1", ";", "if", "(", "!", "flag_pic", ")", "{", "new_literal", "=", "1", ";", "rtx", "mem", "=", "force_const_mem", "(", "Pmode", ",", "*", "label", ")", ";", "rtx_insn", "*", "set_insn", "=", "emit_insn_before", "(", "gen_rtx_SET", "(", "temp_reg", ",", "mem", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "set_insn", ",", "-", "1", ")", ";", "annotate_constant_pool_refs", "(", "&", "PATTERN", "(", "set_insn", ")", ")", ";", "target", "=", "temp_reg", ";", "}", "else", "{", "new_literal", "=", "1", ";", "target", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "*", "label", ")", ",", "UNSPEC_LTREL_OFFSET", ")", ";", "target", "=", "gen_rtx_CONST", "(", "Pmode", ",", "target", ")", ";", "target", "=", "force_const_mem", "(", "Pmode", ",", "target", ")", ";", "rtx_insn", "*", "set_insn", "=", "emit_insn_before", "(", "gen_rtx_SET", "(", "temp_reg", ",", "target", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "set_insn", ",", "-", "1", ")", ";", "annotate_constant_pool_refs", "(", "&", "PATTERN", "(", "set_insn", ")", ")", ";", "target", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "XEXP", "(", "target", ",", "0", ")", ",", "cfun", "->", "machine", "->", "base_reg", ")", ",", "UNSPEC_LTREL_BASE", ")", ";", "target", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp_reg", ",", "target", ")", ";", "}", "ret", "=", "validate_change", "(", "insn", ",", "label", ",", "target", ",", "0", ")", ";", "gcc_assert", "(", "ret", ")", ";", "}", "return", "new_literal", ";", "}", "</s>" ]

[ "Split", "all", "branches", "that", "exceed", "the", "maximum", "distance", ".", "Returns", "true", "if", "this", "created", "a", "new", "literal", "pool", "entry", "." ]

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

[]

[ "<s>", "SDValue", "XCoreSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "unsigned", "SizeBitWidth", "=", "Size", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "!", "AlwaysInline", "&&", "(", "Align", "&", "3", ")", "==", "0", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Size", ",", "APInt", "(", "SizeBitWidth", ",", "3", ")", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "\"__memcpy_4\"", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "3", "0", "3", "\"__memcpy_4\"", "0" ]

[]

[ "<s>", "AArch64Subtarget", "&", "AArch64Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "FS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "initializeProperties", "(", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"generic\"" ]

[]

[ "<s>", "int", "m32c_expand_movmemhi", "(", "rtx", "*", "operands", ")", "{", "rtx", "desta", ",", "srca", ",", "count", ";", "rtx", "desto", ",", "srco", ",", "counto", ";", "desta", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "srca", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "count", "=", "operands", "[", "2", "]", ";", "desto", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "srco", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "counto", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "if", "(", "GET_CODE", "(", "desta", ")", "!=", "REG", "||", "REGNO", "(", "desta", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "desta", "=", "copy_to_mode_reg", "(", "Pmode", ",", "desta", ")", ";", "if", "(", "GET_CODE", "(", "srca", ")", "!=", "REG", "||", "REGNO", "(", "srca", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "srca", "=", "copy_to_mode_reg", "(", "Pmode", ",", "srca", ")", ";", "if", "(", "GET_CODE", "(", "count", ")", "==", "CONST_INT", "&&", "!", "(", "INTVAL", "(", "count", ")", "&", "1", ")", "&&", "(", "INTVAL", "(", "count", ")", ">", "1", ")", ")", "{", "count", "=", "copy_to_mode_reg", "(", "HImode", ",", "GEN_INT", "(", "INTVAL", "(", "count", ")", "/", "2", ")", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_movmemhi_whi_op", "(", "desto", ",", "srco", ",", "counto", ",", "desta", ",", "srca", ",", "count", ")", ")", ";", "else", "emit_insn", "(", "gen_movmemhi_wpsi_op", "(", "desto", ",", "srco", ",", "counto", ",", "desta", ",", "srca", ",", "count", ")", ")", ";", "return", "1", ";", "}", "if", "(", "GET_CODE", "(", "count", ")", "!=", "REG", "||", "REGNO", "(", "count", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "count", "=", "copy_to_mode_reg", "(", "HImode", ",", "count", ")", ";", "if", "(", "TARGET_A16", ")", "emit_insn", "(", "gen_movmemhi_bhi_op", "(", "desto", ",", "srco", ",", "counto", ",", "desta", ",", "srca", ",", "count", ")", ")", ";", "else", "emit_insn", "(", "gen_movmemhi_bpsi_op", "(", "desto", ",", "srco", ",", "counto", ",", "desta", ",", "srca", ",", "count", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "This", "is", "a", "memcpy", "(", ")", "opcode", ".", "All", "operands", "are", "implied", ",", "so", "we", "need", "to", "arrange", "for", "them", "to", "be", "in", "the", "right", "registers", ".", "The", "opcode", "wants", "addresses", ",", "not", "[", "mem", "]", "syntax", ".", "$", "0", "is", "the", "destination", "(", "MEM", ":", "BLK", ")", ",", "$", "1", "is", "the", "source", "(", "MEM", ":", "BLK", ")", ",", "and", "$", "2", "the", "count", "(", "HI", ")", "." ]

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

[]

[ "<s>", "const", "HexagonInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getMaxValue", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "~", "(", "-", "1U", "<<", "(", "bits", "-", "1", ")", ")", ";", "else", "return", "~", "(", "-", "1U", "<<", "bits", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1U", "1", "1U" ]

[]

[ "<s>", "static", "bool", "ix86_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "AX_REG", ":", "return", "true", ";", "case", "DX_REG", ":", "return", "(", "!", "TARGET_64BIT", "||", "ix86_cfun_abi", "(", ")", "!=", "MS_ABI", ")", ";", "case", "DI_REG", ":", "case", "SI_REG", ":", "return", "TARGET_64BIT", "&&", "ix86_cfun_abi", "(", ")", "!=", "MS_ABI", ";", "case", "ST0_REG", ":", "case", "ST1_REG", ":", "if", "(", "TARGET_64BIT", "&&", "ix86_cfun_abi", "(", ")", "==", "MS_ABI", ")", "return", "false", ";", "return", "TARGET_FLOAT_RETURNS_IN_80387", ";", "case", "XMM0_REG", ":", "case", "XMM1_REG", ":", "return", "TARGET_SSE", ";", "case", "MM0_REG", ":", "if", "(", "TARGET_MACHO", "||", "TARGET_64BIT", ")", "return", "false", ";", "return", "TARGET_MMX", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "N", "is", "a", "possible", "register", "number", "of", "function", "value", "." ]

[ "i386" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "}", "}", "else", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_RESTORE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_RESTORE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "1", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "8", "32", "SI", "64", "SI", "96", "SI", "128", "SI", "256", "SI", "512", "SI", "1", "4", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"" ]

[]

[ "<s>", "void", "rbt_inorder_callback", "(", "struct", "rbt_strings", "*", "t", ",", "struct", "rbt_string_node", "*", "subtree", ",", "void", "(", "*", "fn", ")", "(", "char", "*", ")", ")", "{", "if", "(", "subtree", "!=", "t", "->", "rbt_nil", ")", "{", "rbt_inorder_callback", "(", "t", ",", "subtree", "->", "left", ",", "fn", ")", ";", "(", "*", "fn", ")", "(", "subtree", "->", "str", ")", ";", "rbt_inorder_callback", "(", "t", ",", "subtree", "->", "right", ",", "fn", ")", ";", "}", "}", "</s>" ]

[ "Inorder", "call-back", "for", "iteration", "over", "the", "tree", "." ]

[ "rs6000" ]

[]

[ "<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "TVMInstrInfo", "::", "ReplaceUsesOfBlockWith", "(", "MachineBasicBlock", "*", "Pred", ",", "MachineBasicBlock", "*", "Old", ",", "MachineBasicBlock", "*", "New", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "Pred", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "MachineInstr", "&", "Term", ":", "Pred", "->", "terminators", "(", ")", ")", "{", "enumMBBoperands", "(", "Term", ",", "[", "&", "]", "(", "MachineOperand", "&", "Op", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", ";", "unsigned", "MbbReg", "=", "Op", ".", "getReg", "(", ")", ";", "auto", "*", "PushMI", "=", "MRI", ".", "getVRegDef", "(", "MbbReg", ")", ";", "if", "(", "PushMI", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "PUSHCONT_MBB", ")", "return", ";", "assert", "(", "PushMI", "->", "getOperand", "(", "1", ")", ".", "isMBB", "(", ")", "&&", "\"PUSHCONT_MBB op is not MBB\"", ")", ";", "if", "(", "PushMI", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", "==", "Old", ")", "{", "if", "(", "MRI", ".", "hasOneNonDBGUse", "(", "MbbReg", ")", ")", "{", "PushMI", "->", "getOperand", "(", "1", ")", ".", "setMBB", "(", "New", ")", ";", "}", "else", "{", "auto", "it", "=", "Pred", "->", "getFirstTerminator", "(", ")", ";", "auto", "DL", "=", "it", "->", "getDebugLoc", "(", ")", ";", "MbbReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "*", "Pred", ",", "it", ",", "DL", ",", "get", "(", "TVM", "::", "PUSHCONT_MBB", ")", ",", "MbbReg", ")", ".", "addMBB", "(", "New", ")", ".", "addImm", "(", "0", ")", ";", "Op", ".", "setReg", "(", "MbbReg", ")", ";", "}", "}", "}", ")", ";", "}", "Pred", "->", "replaceSuccessor", "(", "Old", ",", "New", ")", ";", "}", "</s>" ]

[ "Given", "a", "machine", "basic", "block", "that", "branched", "to", "'Old", "'", ",", "change", "the", "code", "and", "CFG", "so", "that", "it", "branches", "to", "'New", "'", "instead", "." ]

[ "TVM", "TVM", "TVM::PUSHCONT_MBB", "1", "\"PUSHCONT_MBB op is not MBB\"", "1", "1", "TVM::I257RegClass", "TVM::PUSHCONT_MBB", "0" ]

[]

[ "<s>", "void", "xstormy16_expand_iorqi3", "(", "rtx", "*", "operands", ")", "{", "rtx", "in", ",", "out", ",", "outsub", ",", "val", ";", "out", "=", "operands", "[", "0", "]", ";", "in", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "if", "(", "xstormy16_onebit_set_operand", "(", "val", ",", "QImode", ")", ")", "{", "if", "(", "!", "xstormy16_below100_or_register", "(", "in", ",", "QImode", ")", ")", "in", "=", "copy_to_mode_reg", "(", "QImode", ",", "in", ")", ";", "if", "(", "!", "xstormy16_below100_or_register", "(", "out", ",", "QImode", ")", ")", "out", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "emit_insn", "(", "gen_iorqi3_internal", "(", "out", ",", "in", ",", "val", ")", ")", ";", "if", "(", "out", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "out", ")", ";", "return", ";", "}", "if", "(", "!", "REG_P", "(", "in", ")", ")", "in", "=", "copy_to_mode_reg", "(", "QImode", ",", "in", ")", ";", "if", "(", "!", "REG_P", "(", "val", ")", "&&", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "copy_to_mode_reg", "(", "QImode", ",", "val", ")", ";", "if", "(", "!", "REG_P", "(", "out", ")", ")", "out", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "in", "=", "simplify_gen_subreg", "(", "HImode", ",", "in", ",", "QImode", ",", "0", ")", ";", "outsub", "=", "simplify_gen_subreg", "(", "HImode", ",", "out", ",", "QImode", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "simplify_gen_subreg", "(", "HImode", ",", "val", ",", "QImode", ",", "0", ")", ";", "emit_insn", "(", "gen_iorhi3", "(", "outsub", ",", "in", ",", "val", ")", ")", ";", "if", "(", "out", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "out", ")", ";", "}", "</s>" ]

[ "Expand", "an", "8-bit", "IOR", ".", "This", "either", "detects", "the", "one", "case", "we", "can", "actually", "do", ",", "or", "uses", "a", "16-bit", "IOR", "." ]

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

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getIRStackGuard", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isTargetGlibc", "(", ")", ")", "return", "TargetLowering", "::", "getIRStackGuard", "(", "IRB", ")", ";", "unsigned", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x28", ":", "0x14", ";", "unsigned", "AddressSpace", "=", "getAddressSpace", "(", ")", ";", "return", "ConstantExpr", "::", "getIntToPtr", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "IRB", ".", "getContext", "(", ")", ")", ",", "Offset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "AddressSpace", ")", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "location", "for", "the", "stack", "protector", "cookie", ",", "returns", "the", "address", "of", "that", "location", "." ]

[ "X86", "X86", "0x28", "0x14" ]

[]

[ "<s>", "bool", "CJGFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "CJGMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "CJGMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "CJG", "::", "PUSH", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "CJG", "CJG", "2", "0", "1", "CJG::PUSH" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "for", "(", "Type", "*", "ParamTy", ":", "FTy", "->", "params", "(", ")", ")", "{", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "ParamTy", ")", ";", "if", "(", "PtrTy", "&&", "PtrTy", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemLimit", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "return", "false", ";", "}", "}", "LocalMemLimit", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "if", "(", "LocalMemLimit", "==", "0", ")", "return", "false", ";", "const", "DataLayout", "&", "DL", "=", "Mod", "->", "getDataLayout", "(", ")", ";", "CurrentLocalMemUsage", "=", "0", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "Mod", "->", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "const", "User", "*", "U", ":", "GV", ".", "users", "(", ")", ")", "{", "const", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "{", "unsigned", "Align", "=", "GV", ".", "getAlignment", "(", ")", ";", "if", "(", "Align", "==", "0", ")", "Align", "=", "DL", ".", "getABITypeAlignment", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "uint64_t", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "CurrentLocalMemUsage", "=", "alignTo", "(", "CurrentLocalMemUsage", ",", "Align", ")", ";", "CurrentLocalMemUsage", "+=", "AllocSize", ";", "break", ";", "}", "}", "}", "unsigned", "MaxOccupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "CurrentLocalMemUsage", ")", ";", "unsigned", "OccupancyHint", "=", "AMDGPU", "::", "getIntegerAttribute", "(", "F", ",", "\"amdgpu-max-waves-per-eu\"", ",", "0", ")", ";", "if", "(", "OccupancyHint", "==", "0", ")", "OccupancyHint", "=", "7", ";", "OccupancyHint", "=", "std", "::", "min", "(", "OccupancyHint", ",", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "MaxOccupancy", "=", "std", "::", "min", "(", "OccupancyHint", ",", "MaxOccupancy", ")", ";", "unsigned", "MaxSizeWithWaveCount", "=", "ST", ".", "getMaxLocalMemSizeWithWaveCount", "(", "MaxOccupancy", ")", ";", "if", "(", "CurrentLocalMemUsage", ">", "MaxSizeWithWaveCount", ")", "return", "false", ";", "LocalMemLimit", "=", "MaxSizeWithWaveCount", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" uses \"", "<<", "CurrentLocalMemUsage", "<<", "\" bytes of LDS\\n\"", "<<", "\" Rounding size to \"", "<<", "MaxSizeWithWaveCount", "<<", "\" with a maximum occupancy of \"", "<<", "MaxOccupancy", "<<", "'\\n'", "<<", "\" and \"", "<<", "(", "LocalMemLimit", "-", "CurrentLocalMemUsage", ")", "<<", "\" available for promotion\\n\"", ")", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "handleAlloca", "(", "*", "AI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "0", "AMDGPU", "0", "AMDGPU::getIntegerAttribute", "\"amdgpu-max-waves-per-eu\"", "0", "0", "7", "\" uses \"", "\" bytes of LDS\\n\"", "\" Rounding size to \"", "\" with a maximum occupancy of \"", "\" and \"", "\" available for promotion\\n\"" ]

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_X", ":", "if", "(", "!", "selectAddr", "(", "nullptr", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "tilepro_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "(", "arg", ".", "type", "&&", "TYPE_SIZE", "(", "arg", ".", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "arg", ".", "type", ")", ")", "!=", "INTEGER_CST", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", ".", "Variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TmpMBB", "=", "const_cast", "<", "MachineBasicBlock", "*", ">", "(", "&", "MBB", ")", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "RegInfo", "->", "hasStackRealignment", "(", "*", "MF", ")", ")", "return", "true", ";", "return", "findScratchNonCalleeSaveRegister", "(", "TmpMBB", ")", "!=", "AArch64", "::", "NoRegister", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::NoRegister" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "RISCVTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "CI", ")", "const", "{", "unsigned", "Size", "=", "CI", "->", "getCompareOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "8", "||", "Size", "==", "16", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "RI5CY", "RISCV", "8", "16" ]

[]

[ "<s>", "int", "nios2_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "offset", ";", "nios2_compute_frame_layout", "(", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "args_size", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "total_size", ";", "offset", "-=", "crtl", "->", "args", ".", "pretend_args_size", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "-=", "(", "cfun", "->", "machine", "->", "save_regs_offset", "+", "cfun", "->", "machine", "->", "fp_save_offset", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", "macro", "." ]

[ "nios2" ]

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Sparc", "128" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStOffsetOp", "(", "const", "MachineInstr", "*", "MI", ")", "{", "return", "MI", "->", "getOperand", "(", "2", ")", ";", "}", "</s>" ]

[ "Returns", "the", "immediate", "offset", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "2" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "static", "bool", "nds32_warn_func_return", "(", "tree", "decl", ")", "{", "return", "!", "nds32_naked_function_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "we", "need", "to", "enable", "warning", "for", "function", "return", "check", "." ]

[ "nds32" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "lowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DEBUGTRAP", ":", "return", "lowerDEBUGTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FCANONICALIZE", ":", "return", "splitUnaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "return", "lowerFMINNUM_FMAXNUM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "UMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FMUL", ":", "case", "ISD", "::", "FMINNUM_IEEE", ":", "case", "ISD", "::", "FMAXNUM_IEEE", ":", "return", "splitBinaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::BRCOND", "ISD::RETURNADDR", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::FP_ROUND", "ISD::TRAP", "ISD::DEBUGTRAP", "ISD::FABS", "ISD::FNEG", "ISD::FCANONICALIZE", "ISD::FMINNUM", "ISD::FMAXNUM", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::SMIN", "ISD::SMAX", "ISD::UMIN", "ISD::UMAX", "ISD::FADD", "ISD::FMUL", "ISD::FMINNUM_IEEE", "ISD::FMAXNUM_IEEE" ]

[]

[ "<s>", "int", "nds32_can_use_return_insn", "(", "void", ")", "{", "int", "sp_adjust", ";", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_as_gp_p", "&&", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", "&&", "NDS32_V3PUSH_AVAILABLE_P", "&&", "!", "(", "TARGET_HARD_FLOAT", "&&", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", ")", ")", "return", "1", ";", "return", "(", "cfun", "->", "machine", "->", "naked_p", "&&", "(", "cfun", "->", "machine", "->", "va_args_size", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "nds32", "0", "1", "0" ]

[]

[ "<s>", "void", "rs6000_gen_section_name", "(", "char", "*", "*", "buf", ",", "const", "char", "*", "filename", ",", "const", "char", "*", "section_desc", ")", "{", "const", "char", "*", "q", ",", "*", "after_last_slash", ",", "*", "last_period", "=", "0", ";", "char", "*", "p", ";", "int", "len", ";", "after_last_slash", "=", "filename", ";", "for", "(", "q", "=", "filename", ";", "*", "q", ";", "q", "++", ")", "{", "if", "(", "*", "q", "==", "'/'", ")", "after_last_slash", "=", "q", "+", "1", ";", "else", "if", "(", "*", "q", "==", "'.'", ")", "last_period", "=", "q", ";", "}", "len", "=", "strlen", "(", "after_last_slash", ")", "+", "strlen", "(", "section_desc", ")", "+", "2", ";", "*", "buf", "=", "(", "char", "*", ")", "xmalloc", "(", "len", ")", ";", "p", "=", "*", "buf", ";", "*", "p", "++", "=", "'_'", ";", "for", "(", "q", "=", "after_last_slash", ";", "*", "q", ";", "q", "++", ")", "{", "if", "(", "q", "==", "last_period", ")", "{", "strcpy", "(", "p", ",", "section_desc", ")", ";", "p", "+=", "strlen", "(", "section_desc", ")", ";", "break", ";", "}", "else", "if", "(", "ISALNUM", "(", "*", "q", ")", ")", "*", "p", "++", "=", "*", "q", ";", "}", "if", "(", "last_period", "==", "0", ")", "strcpy", "(", "p", ",", "section_desc", ")", ";", "else", "*", "p", "=", "'\\0'", ";", "}", "</s>" ]

[ "Generate", "a", "unique", "section", "name", "for", "FILENAME", "for", "a", "section", "type", "represented", "by", "SECTION_DESC", ".", "Output", "goes", "into", "BUF", ".", "SECTION_DESC", "can", "be", "any", "string", ",", "as", "long", "as", "it", "is", "different", "for", "each", "possible", "section", "type", ".", "We", "name", "the", "section", "in", "the", "same", "manner", "as", "xlc", ".", "The", "name", "begins", "with", "an", "underscore", "followed", "by", "the", "filename", "(", "after", "stripping", "any", "leading", "directory", "names", ")", "with", "the", "last", "period", "replaced", "by", "the", "string", "SECTION_DESC", ".", "If", "FILENAME", "does", "not", "contain", "a", "period", ",", "SECTION_DESC", "is", "appended", "to", "the", "end", "of", "the", "name", "." ]

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

[]

[ "<s>", "static", "inline", "unsigned", "slice", "(", "uint32_t", "Bits", ",", "unsigned", "From", ",", "unsigned", "To", ")", "{", "assert", "(", "From", "<", "32", "&&", "To", "<", "32", "&&", "From", ">=", "To", ")", ";", "return", "(", "Bits", ">>", "To", ")", "&", "(", "(", "1", "<<", "(", "From", "-", "To", "+", "1", ")", ")", "-", "1", ")", ";", "}", "</s>" ]

[ "Return", "a", "reference", "to", "the", "substring", "from", "[", "Start", ",", "End", ")", "." ]

[ "ARM", "32", "32", "1", "1", "1" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SDIV", ")", "return", "SDValue", "(", ")", ";", "const", "auto", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "DAG", ".", "getSubtarget", "(", ")", ")", ";", "const", "bool", "MinSize", "=", "ST", ".", "optForMinSize", "(", ")", ";", "const", "bool", "HasDivide", "=", "ST", ".", "isThumb", "(", ")", "?", "ST", ".", "hasDivideInThumbMode", "(", ")", ":", "ST", ".", "hasDivideInARMMode", "(", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "isVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "MinSize", "&&", "HasDivide", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "ST", ".", "isThumb", "(", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "if", "(", "Divisor", ".", "sgt", "(", "128", ")", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "ARM", "ARM", "ISD::SDIV", "ARM", "ARM", "0", "0", "128", "0" ]

[]

[ "<s>", "void", "alpha_split_tfmode_pair", "(", "rtx", "operands", "[", "4", "]", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "TFmode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "TFmode", "OP", "[", "1", "]", "into", "DImode", "OP", "[", "2,3", "]", "and", "likewise", "for", "OP", "[", "0", "]", "into", "OP", "[", "0,1", "]", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", "." ]

[ "alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0" ]

[]

[ "<s>", "bool", "AArch64BranchTargets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "branchTargetEnforcement", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Branch Targets **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "JumpTableTargets", ";", "if", "(", "auto", "*", "JTI", "=", "MF", ".", "getJumpTableInfo", "(", ")", ")", "for", "(", "auto", "&", "JTE", ":", "JTI", "->", "getJumpTables", "(", ")", ")", "for", "(", "auto", "*", "MBB", ":", "JTE", ".", "MBBs", ")", "JumpTableTargets", ".", "insert", "(", "MBB", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "CouldCall", "=", "false", ",", "CouldJump", "=", "false", ";", "if", "(", "&", "MBB", "==", "&", "*", "MF", ".", "begin", "(", ")", "&&", "(", "F", ".", "hasAddressTaken", "(", ")", "||", "!", "F", ".", "hasLocalLinkage", "(", ")", ")", ")", "CouldCall", "=", "true", ";", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", "||", "JumpTableTargets", ".", "count", "(", "&", "MBB", ")", ")", "CouldJump", "=", "true", ";", "if", "(", "CouldCall", "||", "CouldJump", ")", "{", "addBTI", "(", "MBB", ",", "CouldCall", ",", "CouldJump", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"********** AArch64 Branch Targets **********\\n\"", "\"********** Function: \"", "8" ]

[]

[ "<s>", "static", "unsigned", "getOpcode_EXTEND", "(", "unsigned", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "ANY_EXTEND", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "ZERO_EXTEND", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ":", "return", "ISD", "::", "SIGN_EXTEND", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode\"", ")", ";", "}", "</s>" ]

[ "Convert", "*", "_EXTEND_VECTOR_INREG", "to", "*", "_EXTEND", "opcode", "." ]

[ "X86", "ISD::ANY_EXTEND", "ISD::ANY_EXTEND_VECTOR_INREG", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::ZERO_EXTEND_VECTOR_INREG", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_VECTOR_INREG", "ISD::SIGN_EXTEND", "\"Unknown opcode\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "void", "rs6000_elf_output_toc_section_asm_op", "(", "const", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "TARGET_MINIMAL_TOC", ")", "{", "if", "(", "!", "toc_initialized", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "TOC_SECTION_ASM_OP", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "TARGET_64BIT", "?", "3", ":", "2", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"LCTOC\"", ",", "0", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.tc \"", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "asm_out_file", ",", "\"LCTOC1[TC],\"", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "asm_out_file", ",", "\"LCTOC1\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "MINIMAL_TOC_SECTION_ASM_OP", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "TARGET_64BIT", "?", "3", ":", "2", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "asm_out_file", ",", "\"LCTOC1\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\" = .+32768\\n\"", ")", ";", "toc_initialized", "=", "1", ";", "}", "else", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "MINIMAL_TOC_SECTION_ASM_OP", ")", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "TOC_SECTION_ASM_OP", ")", ";", "if", "(", "!", "toc_initialized", ")", "{", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "TARGET_64BIT", "?", "3", ":", "2", ")", ";", "toc_initialized", "=", "1", ";", "}", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "MINIMAL_TOC_SECTION_ASM_OP", ")", ";", "if", "(", "!", "toc_initialized", ")", "{", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "TARGET_64BIT", "?", "3", ":", "2", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL_PREFIX", "(", "asm_out_file", ",", "\"LCTOC1\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\" = .+32768\\n\"", ")", ";", "toc_initialized", "=", "1", ";", "}", "}", "}", "</s>" ]

[ "A", "get_unnamed_section", "callback", ",", "used", "for", "switching", "to", "toc_section", "." ]

[ "powerpcspe", "\"%s\\n\"", "3", "2", "\"LCTOC\"", "0", "\"\\t.tc \"", "\"LCTOC1[TC],\"", "\"LCTOC1\"", "\"\\n\"", "\"%s\\n\"", "3", "2", "\"LCTOC1\"", "\" = .+32768\\n\"", "1", "\"%s\\n\"", "\"%s\\n\"", "3", "2", "1", "\"%s\\n\"", "3", "2", "\"LCTOC1\"", "\" = .+32768\\n\"", "1" ]

[]

[ "<s>", "rtx", "spu_const", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "rtx", "inner", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "return", "immed_double_const", "(", "val", ",", "0", ",", "mode", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "hwint_to_const_double", "(", "mode", ",", "val", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "inner", "=", "immed_double_const", "(", "val", ",", "0", ",", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "else", "inner", "=", "hwint_to_const_double", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "val", ")", ";", "return", "gen_const_vec_duplicate", "(", "mode", ",", "inner", ")", ";", "}", "</s>" ]

[ "Given", "VAL", ",", "generate", "a", "constant", "appropriate", "for", "MODE", ".", "If", "MODE", "is", "a", "vector", "mode", ",", "every", "element", "will", "be", "VAL", ".", "For", "TImode", ",", "VAL", "will", "be", "zero", "extended", "to", "128", "bits", "." ]

[ "spu", "0", "0" ]

[]

[ "<s>", "void", "SystemZXPLINKFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "MFFrame", ".", "setOffsetAdjustment", "(", "Regs", ".", "getStackPointerBias", "(", ")", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

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

[]

[ "<s>", "void", "rs6000_emit_prologue_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed_indeed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "machine_mode", "reg_mode", "=", "Pmode", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "machine_mode", "fp_reg_mode", "=", "TARGET_HARD_FLOAT", "?", "DFmode", ":", "SFmode", ";", "int", "fp_reg_size", "=", "8", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "{", "rtx", "lr", "=", "gen_rtx_REG", "(", "reg_mode", ",", "LR_REGNO", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "0", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "reg", ",", "lr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "gen_rtx_SET", "(", "reg", ",", "lr", ")", ")", ";", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "mem", "=", "copy_rtx", "(", "SET_DEST", "(", "single_set", "(", "insn", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "lr", ")", ")", ";", "}", "if", "(", "bitmap_bit_p", "(", "components", ",", "2", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "TOC_REGNUM", ")", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "sp_reg", ",", "RS6000_TOC_SAVE_SLOT", ")", ")", ";", "}", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "reg_size", ";", "}", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "64", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "fp_reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "fp_reg_size", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS", "." ]

[ "rs6000", "4", "8", "8", "0", "0", "1", "1", "2", "32", "1", "64", "1" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "M", ".", "empty", "(", ")", ")", "return", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTOCBaseSection", "(", ")", ")", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "const", "unsigned", "EntryByteSize", "=", "Subtarget", "->", "isPPC64", "(", ")", "?", "8", ":", "4", ";", "const", "unsigned", "TOCEntriesByteSize", "=", "TOC", ".", "size", "(", ")", "*", "EntryByteSize", ";", "if", "(", "TOCEntriesByteSize", ">", "32767", ")", "{", "report_fatal_error", "(", "\"Handling of TOC entry displacement larger than 32767 \"", "\"is not yet implemented.\"", ")", ";", "}", "for", "(", "auto", "&", "I", ":", "TOC", ")", "{", "MCSectionXCOFF", "*", "TCEntry", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForTOCEntry", "(", "I", ".", "first", ")", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "TCEntry", ")", ";", "OutStreamer", "->", "emitLabel", "(", "I", ".", "second", ")", ";", "TS", ".", "emitTCEntry", "(", "*", "I", ".", "first", ")", ";", "}", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "32767", "\"Handling of TOC entry displacement larger than 32767 \"", "\"is not yet implemented.\"" ]

[]

[ "<s>", "unsigned", "PPCDispatchGroupSBHazardRecognizer", "::", "PreEmitNoops", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "isLoadAfterStore", "(", "SU", ")", "&&", "CurSlots", "<", "6", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR6", "||", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", ")", "return", "1", ";", "return", "5", "-", "CurSlots", ";", "}", "return", "ScoreboardHazardRecognizer", "::", "PreEmitNoops", "(", "SU", ")", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

[ "PowerPC", "PPC", "6", "PPC", "PPC::DIR_PWR6", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "1", "5" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isEligibleForITBlock", "(", "&", "MI", ")", ")", "return", "false", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "return", "false", ";", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "getSubtarget", "(", ")", ".", "restrictIT", "(", ")", ")", "return", "isV8EligibleForIT", "(", "&", "MI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "OutStreamer", "->", "emitThumbFunc", "(", "CurrentFnSym", ")", ";", "}", "else", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code32", ")", ";", "}", "if", "(", "AFI", "->", "isCmseNSEntryFunction", "(", ")", ")", "{", "MCSymbol", "*", "S", "=", "OutContext", ".", "getOrCreateSymbol", "(", "\"__acle_se_\"", "+", "CurrentFnSym", "->", "getName", "(", ")", ")", ";", "emitLinkage", "(", "&", "MF", "->", "getFunction", "(", ")", ",", "S", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "S", ",", "MCSA_ELF_TypeFunction", ")", ";", "OutStreamer", "->", "emitLabel", "(", "S", ")", ";", "}", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "ARM", "ARM", "\"__acle_se_\"" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ")", "return", "0", ";", "static", "const", "uint16_t", "CallerSavedRegs32Bit", "[", "]", "=", "{", "X86", "::", "EAX", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "0", "}", ";", "static", "const", "uint16_t", "CallerSavedRegs64Bit", "[", "]", "=", "{", "X86", "::", "RAX", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "R8", ",", "X86", "::", "R9", ",", "X86", "::", "R10", ",", "X86", "::", "R11", ",", "0", "}", ";", "unsigned", "Opc", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETI", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "const", "uint16_t", "*", "AsI", "=", "TRI", ".", "getOverlaps", "(", "Reg", ")", ";", "*", "AsI", ";", "++", "AsI", ")", "Uses", ".", "insert", "(", "*", "AsI", ")", ";", "}", "const", "uint16_t", "*", "CS", "=", "Is64Bit", "?", "CallerSavedRegs64Bit", ":", "CallerSavedRegs32Bit", ";", "for", "(", ";", "*", "CS", ";", "++", "CS", ")", "if", "(", "!", "Uses", ".", "count", "(", "*", "CS", ")", ")", "return", "*", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "X86", "0", "X86::EAX", "X86::EDX", "X86::ECX", "0", "X86::RAX", "X86::RDX", "X86::RCX", "X86::RSI", "X86::RDI", "X86::R8", "X86::R9", "X86::R10", "X86::R11", "0", "0", "X86::RET", "X86::RETI", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "nios2_create_cfa_notes", "(", "rtx_insn", "*", "insn", ",", "bool", "epilogue_p", ")", "{", "int", "i", "=", "0", ";", "rtx", "base_reg", ",", "offset", ",", "elt", ",", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "epilogue_p", ")", "{", "elt", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "==", "RETURN", ")", "i", "++", ";", "elt", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "base_reg_adjustment_p", "(", "elt", ",", "&", "base_reg", ",", "&", "offset", ")", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "copy_rtx", "(", "elt", ")", ")", ";", "i", "++", ";", "}", "for", "(", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "{", "elt", "=", "SET_DEST", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "elt", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "elt", ")", ";", "}", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Does", "the", "CFA", "note", "work", "for", "push/pop", "prologue/epilogue", "instructions", "." ]

[ "nios2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "unsigned", "epiphany_special_round_type_align", "(", "tree", "type", ",", "unsigned", "computed", ",", "unsigned", "specified", ")", "{", "unsigned", "align", "=", "MAX", "(", "computed", ",", "specified", ")", ";", "tree", "field", ";", "HOST_WIDE_INT", "total", ",", "max", ";", "unsigned", "try_align", "=", "FASTEST_ALIGNMENT", ";", "if", "(", "maximum_field_alignment", "&&", "try_align", ">", "maximum_field_alignment", ")", "try_align", "=", "maximum_field_alignment", ";", "if", "(", "align", ">=", "try_align", ")", "return", "align", ";", "for", "(", "max", "=", "0", ",", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "tree", "offset", ",", "size", ";", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", "||", "TREE_TYPE", "(", "field", ")", "==", "error_mark_node", ")", "continue", ";", "offset", "=", "bit_position", "(", "field", ")", ";", "size", "=", "DECL_SIZE", "(", "field", ")", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "offset", ")", "||", "!", "tree_fits_uhwi_p", "(", "size", ")", "||", "tree_to_uhwi", "(", "offset", ")", ">=", "try_align", "||", "tree_to_uhwi", "(", "size", ")", ">=", "try_align", ")", "return", "try_align", ";", "total", "=", "tree_to_uhwi", "(", "offset", ")", "+", "tree_to_uhwi", "(", "size", ")", ";", "if", "(", "total", ">", "max", ")", "max", "=", "total", ";", "}", "if", "(", "max", ">=", "(", "HOST_WIDE_INT", ")", "try_align", ")", "align", "=", "try_align", ";", "else", "if", "(", "try_align", ">", "32", "&&", "max", ">=", "32", ")", "align", "=", "max", ">", "32", "?", "64", ":", "32", ";", "return", "align", ";", "}", "</s>" ]

[ "STRUCTURE_SIZE_BOUNDARY", "seems", "a", "bit", "crude", "in", "how", "it", "enlarges", "small", "structs", ".", "Make", "structs", "double-word-aligned", "it", "they", "are", "a", "double", "word", "or", "(", "potentially", ")", "larger", ";", "failing", "that", ",", "do", "the", "same", "for", "a", "size", "of", "32", "bits", "." ]

[ "epiphany", "0", "32", "32", "32", "64", "32" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "getOppositeBranchOpc", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Illegal opcode!\"", ")", ";", "case", "Mips", "::", "BeqzRxImmX16", ":", "return", "Mips", "::", "BnezRxImmX16", ";", "case", "Mips", "::", "BnezRxImmX16", ":", "return", "Mips", "::", "BeqzRxImmX16", ";", "case", "Mips", "::", "BteqzT8CmpX16", ":", "return", "Mips", "::", "BtnezT8CmpX16", ";", "case", "Mips", "::", "BteqzT8SltX16", ":", "return", "Mips", "::", "BtnezT8SltX16", ";", "case", "Mips", "::", "BteqzT8SltiX16", ":", "return", "Mips", "::", "BtnezT8SltiX16", ";", "case", "Mips", "::", "BtnezX16", ":", "return", "Mips", "::", "BteqzX16", ";", "case", "Mips", "::", "BtnezT8CmpiX16", ":", "return", "Mips", "::", "BteqzT8CmpiX16", ";", "case", "Mips", "::", "BtnezT8SltuX16", ":", "return", "Mips", "::", "BteqzT8SltuX16", ";", "case", "Mips", "::", "BtnezT8SltiuX16", ":", "return", "Mips", "::", "BteqzT8SltiuX16", ";", "case", "Mips", "::", "BteqzX16", ":", "return", "Mips", "::", "BtnezX16", ";", "case", "Mips", "::", "BteqzT8CmpiX16", ":", "return", "Mips", "::", "BtnezT8CmpiX16", ";", "case", "Mips", "::", "BteqzT8SltuX16", ":", "return", "Mips", "::", "BtnezT8SltuX16", ";", "case", "Mips", "::", "BteqzT8SltiuX16", ":", "return", "Mips", "::", "BtnezT8SltiuX16", ";", "case", "Mips", "::", "BtnezT8CmpX16", ":", "return", "Mips", "::", "BteqzT8CmpX16", ";", "case", "Mips", "::", "BtnezT8SltX16", ":", "return", "Mips", "::", "BteqzT8SltX16", ";", "case", "Mips", "::", "BtnezT8SltiX16", ":", "return", "Mips", "::", "BteqzT8SltiX16", ";", "}", "assert", "(", "false", "&&", "\"Implement this function.\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]

[ "Mips", "Mips", "\"Illegal opcode!\"", "Mips::BeqzRxImmX16", "Mips::BnezRxImmX16", "Mips::BnezRxImmX16", "Mips::BeqzRxImmX16", "Mips::BteqzT8CmpX16", "Mips::BtnezT8CmpX16", "Mips::BteqzT8SltX16", "Mips::BtnezT8SltX16", "Mips::BteqzT8SltiX16", "Mips::BtnezT8SltiX16", "Mips::BtnezX16", "Mips::BteqzX16", "Mips::BtnezT8CmpiX16", "Mips::BteqzT8CmpiX16", "Mips::BtnezT8SltuX16", "Mips::BteqzT8SltuX16", "Mips::BtnezT8SltiuX16", "Mips::BteqzT8SltiuX16", "Mips::BteqzX16", "Mips::BtnezX16", "Mips::BteqzT8CmpiX16", "Mips::BtnezT8CmpiX16", "Mips::BteqzT8SltuX16", "Mips::BtnezT8SltuX16", "Mips::BteqzT8SltiuX16", "Mips::BtnezT8SltiuX16", "Mips::BtnezT8CmpX16", "Mips::BteqzT8CmpX16", "Mips::BtnezT8SltX16", "Mips::BteqzT8SltX16", "Mips::BtnezT8SltiX16", "Mips::BteqzT8SltiX16", "\"Implement this function.\"", "0" ]

[]

[ "<s>", "virtual", "const", "Dcpu16InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Dcpu16" ]

[]

[ "<s>", "bool", "ix86_expand_pextr", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "unsigned", "int", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "unsigned", "int", "pos", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "SUBREG_P", "(", "dst", ")", ")", "{", "if", "(", "SUBREG_BYTE", "(", "dst", ")", ">", "0", ")", "return", "false", ";", "dst", "=", "SUBREG_REG", "(", "dst", ")", ";", "}", "if", "(", "SUBREG_P", "(", "src", ")", ")", "{", "pos", "+=", "SUBREG_BYTE", "(", "src", ")", "*", "BITS_PER_UNIT", ";", "src", "=", "SUBREG_REG", "(", "src", ")", ";", "}", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V1TImode", ":", "{", "machine_mode", "srcmode", ",", "dstmode", ";", "rtx", "d", ",", "pat", ";", "if", "(", "!", "int_mode_for_size", "(", "size", ",", "0", ")", ".", "exists", "(", "&", "dstmode", ")", ")", "return", "false", ";", "switch", "(", "dstmode", ")", "{", "case", "E_QImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V16QImode", ";", "break", ";", "case", "E_HImode", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "false", ";", "srcmode", "=", "V8HImode", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V4SImode", ";", "break", ";", "case", "E_DImode", ":", "gcc_assert", "(", "TARGET_64BIT", ")", ";", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "srcmode", "=", "V2DImode", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "pos", "&", "(", "size", "-", "1", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "dst", ")", "==", "dstmode", ")", "d", "=", "dst", ";", "else", "d", "=", "gen_reg_rtx", "(", "dstmode", ")", ";", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "GEN_INT", "(", "pos", "/", "size", ")", ")", ")", ";", "pat", "=", "gen_rtx_VEC_SELECT", "(", "dstmode", ",", "gen_lowpart", "(", "srcmode", ",", "src", ")", ",", "pat", ")", ";", "if", "(", "dstmode", "==", "QImode", "||", "dstmode", "==", "HImode", ")", "{", "pat", "=", "gen_rtx_ZERO_EXTEND", "(", "SImode", ",", "pat", ")", ";", "d", "=", "gen_lowpart", "(", "SImode", ",", "d", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "d", ",", "pat", ")", ")", ";", "if", "(", "d", "!=", "dst", ")", "emit_move_insn", "(", "dst", ",", "gen_lowpart", "(", "GET_MODE", "(", "dst", ")", ",", "d", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Expand", "an", "extract", "from", "a", "vector", "register", "through", "pextr", "insn", ".", "Return", "true", "if", "successful", "." ]

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

[]

[ "<s>", "void", "neon_reinterpret", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "emit_move_insn", "(", "dest", ",", "gen_lowpart", "(", "GET_MODE", "(", "dest", ")", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "reinterpret", "one", "Neon", "type", "as", "another", ",", "without", "altering", "bits", "." ]

[ "arm" ]

[]

[ "<s>", "static", "rtx", "aapcs_vfp_allocate_return_reg", "(", "enum", "arm_pcs", "pcs_variant", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "use_vfp_abi", "(", "pcs_variant", ",", "false", ")", ")", "return", "NULL", ";", "if", "(", "mode", "==", "BLKmode", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">=", "GET_MODE_SIZE", "(", "TImode", ")", "&&", "!", "TARGET_NEON", ")", ")", "{", "int", "count", ";", "machine_mode", "ag_mode", ";", "int", "i", ";", "rtx", "par", ";", "int", "shift", ";", "aapcs_vfp_is_call_or_return_candidate", "(", "pcs_variant", ",", "mode", ",", "type", ",", "&", "ag_mode", ",", "&", "count", ")", ";", "if", "(", "!", "TARGET_NEON", ")", "{", "if", "(", "ag_mode", "==", "V2SImode", ")", "ag_mode", "=", "DImode", ";", "else", "if", "(", "ag_mode", "==", "V4SImode", ")", "{", "ag_mode", "=", "DImode", ";", "count", "*=", "2", ";", "}", "}", "shift", "=", "GET_MODE_SIZE", "(", "ag_mode", ")", "/", "GET_MODE_SIZE", "(", "SFmode", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "ag_mode", ",", "FIRST_VFP_REGNUM", "+", "i", "*", "shift", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "GEN_INT", "(", "i", "*", "GET_MODE_SIZE", "(", "ag_mode", ")", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "tmp", ";", "}", "return", "par", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_VFP_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "the", "allocate_return_reg", "field", "in", "aapcs_cp_arg_layout", ".", "See", "the", "comment", "there", "for", "the", "behaviour", "of", "this", "function", "." ]

[ "arm", "2", "0", "0" ]

[]

[ "<s>", "static", "bool", "use_rsqrt_p", "(", "void", ")", "{", "return", "(", "!", "flag_trapping_math", "&&", "flag_unsafe_math_optimizations", "&&", "(", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_APPROX_RSQRT", ")", "||", "flag_mrecip_low_precision_sqrt", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "safe", "to", "use", "the", "rsqrt", "optabs", "to", "optimize", "1.0/sqrt", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "nvptx_function_end", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"}\\n\"", ")", ";", "}", "</s>" ]

[ "Terminate", "a", "function", "by", "writing", "a", "closing", "brace", "to", "FILE", "." ]

[ "nvptx", "\"}\\n\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_comi", "(", "const", "struct", "builtin_description", "*", "d", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ",", "set_dst", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "enum", "insn_code", "icode", "=", "d", "->", "icode", ";", "const", "struct", "insn_data_d", "*", "insn_p", "=", "&", "insn_data", "[", "icode", "]", ";", "machine_mode", "mode0", "=", "insn_p", "->", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_p", "->", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "enum", "rtx_code", "comparison", "=", "d", "->", "comparison", ";", "rtx", "const_val", "=", "const0_rtx", ";", "bool", "check_unordered", "=", "false", ";", "machine_mode", "mode", "=", "CCFPmode", ";", "switch", "(", "comparison", ")", "{", "case", "LE", ":", "case", "LT", ":", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "comparison", "=", "swap_condition", "(", "comparison", ")", ";", "case", "GT", ":", "case", "GE", ":", "break", ";", "case", "EQ", ":", "check_unordered", "=", "true", ";", "mode", "=", "CCZmode", ";", "break", ";", "case", "NE", ":", "check_unordered", "=", "true", ";", "mode", "=", "CCZmode", ";", "const_val", "=", "const1_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "target", ",", "const_val", ")", ";", "target", "=", "gen_rtx_SUBREG", "(", "QImode", ",", "target", ",", "0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op0", ",", "mode0", ")", ")", "||", "!", "insn_p", "->", "operand", "[", "0", "]", ".", "predicate", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op1", ",", "mode1", ")", ")", "||", "!", "insn_p", "->", "operand", "[", "1", "]", ".", "predicate", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "set_dst", "=", "SET_DEST", "(", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "return", "ix86_ssecom_setcc", "(", "comparison", ",", "check_unordered", ",", "mode", ",", "set_dst", ",", "target", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "ix86_expand_builtin", "to", "take", "care", "of", "comi", "insns", "." ]

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

[]

[ "<s>", "bool", "Mips16InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Src", ",", "const", "MachineOperand", "*", "&", "Dest", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "{", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

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

[]

[ "<s>", "unsigned", "WebAssemblyTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "unsigned", "Cost", "=", "BasicTTIImplBase", "<", "WebAssemblyTTIImpl", ">", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "if", "(", "auto", "*", "VTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "{", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "if", "(", "Opd2Info", "!=", "TTI", "::", "OK_UniformValue", "&&", "Opd2Info", "!=", "TTI", "::", "OK_UniformConstantValue", ")", "Cost", "=", "VTy", "->", "getNumElements", "(", ")", "*", "(", "TargetTransformInfo", "::", "TCC_Basic", "+", "getArithmeticInstrCost", "(", "Opcode", ",", "VTy", "->", "getElementType", "(", ")", ")", "+", "TargetTransformInfo", "::", "TCC_Basic", ")", ";", "break", ";", "}", "}", "return", "Cost", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

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

[]

[ "<s>", "bool", "aarch64_operands_ok_for_ldpstp", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "enum", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "offval_1", ",", "offval_2", ",", "msize", ";", "enum", "reg_class", "rclass_1", ",", "rclass_2", ";", "rtx", "mem_1", ",", "mem_2", ",", "reg_1", ",", "reg_2", ",", "base_1", ",", "base_2", ",", "offset_1", ",", "offset_2", ";", "if", "(", "load", ")", "{", "mem_1", "=", "operands", "[", "1", "]", ";", "mem_2", "=", "operands", "[", "3", "]", ";", "reg_1", "=", "operands", "[", "0", "]", ";", "reg_2", "=", "operands", "[", "2", "]", ";", "gcc_assert", "(", "REG_P", "(", "reg_1", ")", "&&", "REG_P", "(", "reg_2", ")", ")", ";", "if", "(", "REGNO", "(", "reg_1", ")", "==", "REGNO", "(", "reg_2", ")", ")", "return", "false", ";", "}", "else", "{", "mem_1", "=", "operands", "[", "0", "]", ";", "mem_2", "=", "operands", "[", "2", "]", ";", "reg_1", "=", "operands", "[", "1", "]", ";", "reg_2", "=", "operands", "[", "3", "]", ";", "}", "if", "(", "MEM_VOLATILE_P", "(", "mem_1", ")", "||", "MEM_VOLATILE_P", "(", "mem_2", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_SLOW_UNALIGNED_LDPW", ")", "&&", "!", "optimize_size", "&&", "MEM_ALIGN", "(", "mem_1", ")", "<", "8", "*", "BITS_PER_UNIT", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base_1", ",", "&", "offset_1", ")", ";", "if", "(", "base_1", "==", "NULL_RTX", "||", "offset_1", "==", "NULL_RTX", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_2", ",", "&", "base_2", ",", "&", "offset_2", ")", ";", "if", "(", "base_2", "==", "NULL_RTX", "||", "offset_2", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "base_1", ",", "base_2", ")", ")", "return", "false", ";", "offval_1", "=", "INTVAL", "(", "offset_1", ")", ";", "offval_2", "=", "INTVAL", "(", "offset_2", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offval_1", "!=", "(", "offval_2", "+", "msize", ")", "&&", "offval_2", "!=", "(", "offval_1", "+", "msize", ")", ")", "return", "false", ";", "if", "(", "load", ")", "{", "if", "(", "reg_mentioned_p", "(", "reg_1", ",", "mem_1", ")", ")", "return", "false", ";", "if", "(", "offval_1", ">", "offval_2", "&&", "reg_mentioned_p", "(", "reg_2", ",", "mem_2", ")", ")", "return", "false", ";", "}", "if", "(", "REG_P", "(", "reg_1", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_1", ")", ")", ")", "rclass_1", "=", "FP_REGS", ";", "else", "rclass_1", "=", "GENERAL_REGS", ";", "if", "(", "REG_P", "(", "reg_2", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_2", ")", ")", ")", "rclass_2", "=", "FP_REGS", ";", "else", "rclass_2", "=", "GENERAL_REGS", ";", "if", "(", "rclass_1", "!=", "rclass_2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "check", "if", "we", "can", "merge", "them", "into", "ldp/stp", ".", "LOAD", "is", "true", "if", "they", "are", "load", "instructions", ".", "MODE", "is", "the", "mode", "of", "memory", "operands", "." ]

[ "aarch64", "1", "3", "0", "2", "0", "2", "1", "3", "8" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "isDead", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVector", "<", "MachineInstr", "*", ",", "1", ">", "&", "DeadPhis", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "{", "MachineRegisterInfo", "::", "use_iterator", "I", "=", "MRI", "->", "use_begin", "(", "Reg", ")", ";", "if", "(", "llvm", "::", "next", "(", "I", ")", "==", "MRI", "->", "use_end", "(", ")", "&&", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "{", "MachineInstr", "*", "OnePhi", "=", "I", ".", "getOperand", "(", ")", ".", "getParent", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "f", "=", "OnePhi", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "OPO", "=", "OnePhi", "->", "getOperand", "(", "j", ")", ";", "if", "(", "OPO", ".", "isReg", "(", ")", "&&", "OPO", ".", "isDef", "(", ")", ")", "{", "unsigned", "OPReg", "=", "OPO", ".", "getReg", "(", ")", ";", "MachineRegisterInfo", "::", "use_iterator", "nextJ", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "J", "=", "MRI", "->", "use_begin", "(", "OPReg", ")", ",", "E", "=", "MRI", "->", "use_end", "(", ")", ";", "J", "!=", "E", ";", "J", "=", "nextJ", ")", "{", "nextJ", "=", "llvm", "::", "next", "(", "J", ")", ";", "MachineOperand", "&", "Use", "=", "J", ".", "getOperand", "(", ")", ";", "MachineInstr", "*", "UseMI", "=", "Use", ".", "getParent", "(", ")", ";", "if", "(", "MI", "!=", "UseMI", ")", "{", "return", "false", ";", "}", "}", "}", "}", "DeadPhis", ".", "push_back", "(", "OnePhi", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

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

[]

[ "<s>", "static", "rtx", "gen_float_relational", "(", "enum", "rtx_code", "test_code", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ")", "{", "rtx", "(", "*", "gen_fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "brtmp", ";", "int", "reverse_regs", ",", "invert", ";", "switch", "(", "test_code", ")", "{", "case", "EQ", ":", "reverse_regs", "=", "0", ";", "invert", "=", "0", ";", "gen_fn", "=", "gen_seq_sf", ";", "break", ";", "case", "NE", ":", "reverse_regs", "=", "0", ";", "invert", "=", "1", ";", "gen_fn", "=", "gen_seq_sf", ";", "break", ";", "case", "LE", ":", "reverse_regs", "=", "0", ";", "invert", "=", "0", ";", "gen_fn", "=", "gen_sle_sf", ";", "break", ";", "case", "GT", ":", "reverse_regs", "=", "1", ";", "invert", "=", "0", ";", "gen_fn", "=", "gen_slt_sf", ";", "break", ";", "case", "LT", ":", "reverse_regs", "=", "0", ";", "invert", "=", "0", ";", "gen_fn", "=", "gen_slt_sf", ";", "break", ";", "case", "GE", ":", "reverse_regs", "=", "1", ";", "invert", "=", "0", ";", "gen_fn", "=", "gen_sle_sf", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"bad test\"", ",", "gen_rtx_fmt_ee", "(", "test_code", ",", "VOIDmode", ",", "cmp0", ",", "cmp1", ")", ")", ";", "reverse_regs", "=", "0", ";", "invert", "=", "0", ";", "gen_fn", "=", "0", ";", "}", "if", "(", "reverse_regs", ")", "{", "rtx", "temp", "=", "cmp0", ";", "cmp0", "=", "cmp1", ";", "cmp1", "=", "temp", ";", "}", "brtmp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FPCC_REGNUM", ")", ";", "emit_insn", "(", "gen_fn", "(", "brtmp", ",", "cmp0", ",", "cmp1", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "invert", "?", "EQ", ":", "NE", ",", "VOIDmode", ",", "brtmp", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "code", "to", "compare", "two", "float", "values", ".", "The", "return", "value", "is", "the", "comparison", "expression", "." ]

[ "xtensa", "0", "0", "0", "1", "0", "0", "1", "0", "0", "0", "1", "0", "\"bad test\"", "0", "0", "0" ]

[]

[ "<s>", "Align", "SITargetLowering", "::", "computeKnownAlignForTargetInstr", "(", "GISelKnownBits", "&", "KB", ",", "Register", "R", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "Depth", ")", "const", "{", "const", "MachineInstr", "*", "MI", "=", "MRI", ".", "getVRegDef", "(", "R", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "G_INTRINSIC", ":", "case", "AMDGPU", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "{", "Intrinsic", "::", "ID", "IID", "=", "MI", "->", "getIntrinsicID", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "KB", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "AttributeList", "Attrs", "=", "Intrinsic", "::", "getAttributes", "(", "Ctx", ",", "IID", ")", ";", "if", "(", "MaybeAlign", "RetAlign", "=", "Attrs", ".", "getRetAlignment", "(", ")", ")", "return", "*", "RetAlign", ";", "return", "Align", "(", "1", ")", ";", "}", "default", ":", "return", "Align", "(", "1", ")", ";", "}", "}", "</s>" ]

[ "Determine", "the", "known", "alignment", "for", "the", "pointer", "value", "R", "." ]

[ "AMDGPU", "SI", "AMDGPU::G_INTRINSIC", "AMDGPU::G_INTRINSIC_W_SIDE_EFFECTS", "Intrinsic::ID", "Intrinsic::getAttributes", "1", "1" ]

[]

[ "<s>", "static", "void", "sh_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "ca", "->", "force_mem", ")", "ca", "->", "force_mem", "=", "false", ";", "if", "(", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", "&&", "TARGET_FPU_DOUBLE", ")", "{", "if", "(", "arg", ".", "mode", "==", "SFmode", "&&", "ca", "->", "free_single_fp_reg", ")", "{", "ca", "->", "free_single_fp_reg", "=", "0", ";", "return", ";", "}", "if", "(", "arg", ".", "mode", "==", "DFmode", "&&", "sh_round_reg", "(", "*", "ca", ",", "DFmode", ")", "!=", "sh_round_reg", "(", "*", "ca", ",", "SFmode", ")", ")", "{", "ca", "->", "free_single_fp_reg", "=", "(", "sh_round_reg", "(", "*", "ca", ",", "SFmode", ")", "+", "BASE_ARG_REG", "(", "arg", ".", "mode", ")", ")", ";", "}", "}", "if", "(", "!", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A", ")", "||", "ca", "->", "renesas_abi", ")", "||", "sh_pass_in_reg_p", "(", "*", "ca", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", "(", "ca", "->", "arg_count", "[", "(", "int", ")", "get_sh_arg_class", "(", "arg", ".", "mode", ")", "]", "=", "(", "sh_round_reg", "(", "*", "ca", ",", "arg", ".", "mode", ")", "+", "CEIL", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", ",", "UNITS_PER_WORD", ")", ")", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "sh", "0" ]

[]

[ "<s>", "void", "get_aligned_mem", "(", "rtx", "ref", ",", "rtx", "*", "paligned_mem", ",", "rtx", "*", "pbitnum", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "disp", ",", "offset", ";", "gcc_assert", "(", "GET_CODE", "(", "ref", ")", "==", "MEM", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "else", "disp", "=", "0", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "32", ")", "offset", "=", "0", ";", "else", "offset", "=", "disp", "&", "3", ";", "*", "paligned_mem", "=", "widen_memory_access", "(", "ref", ",", "SImode", ",", "-", "offset", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "offset", "=", "32", "-", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "ref", ")", ")", "+", "offset", "*", "8", ")", ";", "else", "offset", "*=", "8", ";", "*", "pbitnum", "=", "GEN_INT", "(", "offset", ")", ";", "}", "</s>" ]

[ "REF", "is", "an", "alignable", "memory", "location", ".", "Place", "an", "aligned", "SImode", "reference", "into", "*", "PALIGNED_MEM", "and", "the", "number", "of", "bits", "to", "shift", "into", "*", "PBITNUM", ".", "SCRATCH", "is", "a", "free", "register", "for", "use", "in", "reloading", "out", "of", "range", "stack", "slots", "." ]

[ "alpha", "0", "0", "0", "1", "0", "0", "32", "0", "3", "32", "8", "8" ]

[]

[ "<s>", "static", "rtx", "mep_frame_expr", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "note", ",", "expr", ";", "note", "=", "find_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "0", ")", ";", "expr", "=", "(", "note", "!=", "0", "?", "XEXP", "(", "note", ",", "0", ")", ":", "copy_rtx", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "expr", ")", "=", "1", ";", "return", "expr", ";", "}", "</s>" ]

[ "Return", "the", "effect", "of", "frame-related", "instruction", "INSN", "." ]

[ "mep", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "getMemOperandWithOffset", "(", "const", "MachineInstr", "&", "MemOp", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MemOp", ".", "getDesc", "(", ")", ";", "int", "MemRefBegin", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemRefBegin", "<", "0", ")", "return", "false", ";", "MemRefBegin", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "BaseOp", "=", "&", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "return", "false", ";", "const", "MachineOperand", "&", "DispMO", "=", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "!", "DispMO", ".", "isImm", "(", ")", ")", "return", "false", ";", "Offset", "=", "DispMO", ".", "getImm", "(", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Get", "the", "base", "operand", "and", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::AddrScaleAmt", "1", "X86::AddrIndexReg", "X86::NoRegister", "X86::AddrDisp" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "LRUsed", "=", "MRI", ".", "isPhysRegModified", "(", "XCore", "::", "LR", ")", ";", "if", "(", "!", "LRUsed", "&&", "!", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", ".", "estimateStackSize", "(", "MF", ")", ")", "LRUsed", "=", "true", ";", "if", "(", "MF", ".", "callsUnwindInit", "(", ")", "||", "MF", ".", "callsEHReturn", "(", ")", ")", "{", "XFI", "->", "createEHSpillSlot", "(", "MF", ")", ";", "LRUsed", "=", "true", ";", "}", "if", "(", "LRUsed", ")", "{", "SavedRegs", ".", "reset", "(", "XCore", "::", "LR", ")", ";", "XFI", "->", "createLRSpillSlot", "(", "MF", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "XFI", "->", "createFPSpillSlot", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::LR" ]

[]

[ "<s>", "int", "avr_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "0", ";", "else", "{", "int", "offset", "=", "frame_pointer_needed", "?", "2", ":", "0", ";", "int", "avr_pc_size", "=", "AVR_HAVE_EIJMP_EICALL", "?", "3", ":", "2", ";", "offset", "+=", "avr_regs_to_save", "(", "NULL", ")", ";", "return", "(", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", "+", "avr_pc_size", "+", "1", "+", "offset", ")", ";", "}", "}", "</s>" ]

[ "Compute", "offset", "between", "arg_pointer", "and", "frame_pointer", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_save_callee_saves", "(", "machine_mode", "mode", ",", "poly_int64", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ")", "{", "rtx_insn", "*", "insn", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "rtx", "reg", ",", "mem", ";", "poly_int64", "offset", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "if", "(", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "!", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno2", "]", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "mem", ",", "reg", ",", "mem2", ",", "reg2", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "regno", "=", "regno2", ";", "}", "else", "insn", "=", "emit_move_insn", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "the", "callee-saved", "registers", "from", "register", "number", "START", "to", "LIMIT", "to", "the", "stack", "at", "the", "location", "starting", "at", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", "." ]

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

[]

[ "<s>", "static", "bool", "pa_callee_copies", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", ")", "{", "return", "!", "TARGET_CALLER_COPIES", ";", "}", "</s>" ]

[ "Implement", "TARGET_CALLEE_COPIES", ".", "The", "callee", "is", "responsible", "for", "copying", "arguments", "passed", "by", "hidden", "reference", "in", "the", "32-bit", "HP", "runtime", ".", "Users", "can", "override", "this", "behavior", "for", "better", "compatibility", "with", "openmp", "at", "the", "risk", "of", "library", "incompatibilities", ".", "Arguments", "are", "always", "passed", "by", "value", "in", "the", "64-bit", "HP", "runtime", "." ]

[ "pa" ]

[]

[ "<s>", "void", "arm_expand_vcond", "(", "rtx", "*", "operands", ",", "machine_mode", "cmp_result_mode", ")", "{", "rtx", "mask", ";", "if", "(", "TARGET_HAVE_MVE", ")", "mask", "=", "gen_reg_rtx", "(", "arm_mode_to_pred_mode", "(", "cmp_result_mode", ")", ".", "require", "(", ")", ")", ";", "else", "mask", "=", "gen_reg_rtx", "(", "cmp_result_mode", ")", ";", "bool", "inverted", "=", "arm_expand_vector_compare", "(", "mask", ",", "GET_CODE", "(", "operands", "[", "3", "]", ")", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "true", ")", ";", "if", "(", "inverted", ")", "std", "::", "swap", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "TARGET_NEON", ")", "emit_insn", "(", "gen_neon_vbsl", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "0", "]", ",", "mask", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "else", "{", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "cmp_mode", ")", ")", "{", "case", "MODE_VECTOR_INT", ":", "emit_insn", "(", "gen_mve_vpselq", "(", "VPSELQ_S", ",", "cmp_mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "mask", ")", ")", ";", "break", ";", "case", "MODE_VECTOR_FLOAT", ":", "if", "(", "TARGET_HAVE_MVE_FLOAT", ")", "emit_insn", "(", "gen_mve_vpselq_f", "(", "cmp_mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "mask", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "a", "vcond", "or", "vcondu", "pattern", "with", "operands", "OPERANDS", ".", "CMP_RESULT_MODE", "is", "the", "mode", "of", "the", "comparison", "result", "." ]

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

[]

[ "<s>", "static", "bool", "s390_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "if", "(", "from", "==", "BASE_REGNUM", "&&", "to", "==", "BASE_REGNUM", ")", "{", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "s390_init_frame_layout", "(", ")", ";", "return", "cfun", "->", "machine", "->", "base_reg", "==", "NULL_RTX", ";", "}", "return", "false", ";", "}", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", ";", "gcc_assert", "(", "from", "==", "FRAME_POINTER_REGNUM", "||", "from", "==", "ARG_POINTER_REGNUM", "||", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", ";", "if", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "if", "(", "!", "crtl", "->", "calls_eh_return", "&&", "!", "cfun", "->", "stdarg", "&&", "!", "cfun_frame_layout", ".", "save_return_addr_p", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "FROM", "can", "be", "eliminated", "via", "register", "TO", "." ]

[ "s390" ]

[]

[ "<s>", "static", "rtx_insn", "*", "avr_parallel_insn_from_insns", "(", "rtx_insn", "*", "i", "[", "5", "]", ")", "{", "rtvec", "vec", "=", "gen_rtvec", "(", "5", ",", "PATTERN", "(", "i", "[", "0", "]", ")", ",", "PATTERN", "(", "i", "[", "1", "]", ")", ",", "PATTERN", "(", "i", "[", "2", "]", ")", ",", "PATTERN", "(", "i", "[", "3", "]", ")", ",", "PATTERN", "(", "i", "[", "4", "]", ")", ")", ";", "start_sequence", "(", ")", ";", "emit", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ")", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Make", "one", "parallel", "insn", "with", "all", "the", "patterns", "from", "insns", "i", "[", "0", "]", "..", "i", "[", "5", "]", "." ]

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

[]

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

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "ARM" ]

[]

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

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "ARM" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_R", ":", "case", "InlineAsm", "::", "Constraint_S", ":", "case", "InlineAsm", "::", "Constraint_T", ":", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "if", "(", "selectBDXAddr", "(", "SystemZAddressingMode", "::", "FormBD", ",", "SystemZAddressingMode", "::", "Disp12Only", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "{", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Unexpected asm memory constraint\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only" ]

[]

[ "<s>", "static", "const", "char", "*", "pa_strip_name_encoding", "(", "const", "char", "*", "str", ")", "{", "str", "+=", "(", "*", "str", "==", "'@'", ")", ";", "str", "+=", "(", "*", "str", "==", "'*'", ")", ";", "return", "str", ";", "}", "</s>" ]

[ "This", "is", "sort", "of", "inverse", "to", "pa_encode_section_info", "." ]

[ "pa" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "break", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "Res", "=", "ExpandBIT_CONVERT", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "LowerShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BIT_CONVERT", "ISD::SRL", "ISD::SRA" ]

[]

[ "<s>", "bool", "PPCFunctionInfo", "::", "isLiveInZExt", "(", "Register", "VReg", ")", "const", "{", "for", "(", "const", "std", "::", "pair", "<", "Register", ",", "ISD", "::", "ArgFlagsTy", ">", "&", "LiveIn", ":", "LiveInAttrs", ")", "if", "(", "LiveIn", ".", "first", "==", "VReg", ")", "return", "LiveIn", ".", "second", ".", "isZExt", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "the", "specified", "vreg", "is", "a", "live-in", "register", "and", "zero-extended", "." ]

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

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "VE" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", ")", "{", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "Reloc", "::", "Model", "R", "=", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ";", "if", "(", "!", "X86", "::", "isOffsetSuitableForCodeModel", "(", "AM", ".", "BaseOffs", ",", "M", ",", "AM", ".", "BaseGV", "!=", "NULL", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "unsigned", "GVFlags", "=", "Subtarget", "->", "ClassifyGlobalReference", "(", "AM", ".", "BaseGV", ",", "getTargetMachine", "(", ")", ")", ";", "if", "(", "isGlobalStubReference", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "isGlobalRelativeToPICBase", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "(", "M", "!=", "CodeModel", "::", "Small", "||", "R", "!=", "Reloc", "::", "Static", ")", "&&", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "Scale", ">", "1", ")", ")", "return", "false", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "case", "3", ":", "case", "5", ":", "case", "9", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "X86::isOffsetSuitableForCodeModel", "1", "0", "1", "2", "4", "8", "3", "5", "9" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "DAG", "->", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "delete", "Top", ".", "ResourceModel", ";", "delete", "Bot", ".", "ResourceModel", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "assert", "(", "(", "!", "llvm", "::", "ForceTopDown", "||", "!", "llvm", "::", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "DAG", "->", "addMutation", "(", "make_unique", "<", "HexagonSubtarget", "::", "HexagonDAGMutation", ">", "(", ")", ")", ";", "DAG", "->", "addMutation", "(", "make_unique", "<", "HexagonCallMutation", ">", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "\"-misched-topdown incompatible with -misched-bottomup\"", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "struct", "s390_address", "ad", ";", "if", "(", "!", "s390_decompose_address", "(", "addr", ",", "&", "ad", ")", "||", "(", "ad", ".", "base", "&&", "!", "REG_OK_FOR_BASE_STRICT_P", "(", "ad", ".", "base", ")", ")", "||", "(", "ad", ".", "indx", "&&", "!", "REG_OK_FOR_INDEX_STRICT_P", "(", "ad", ".", "indx", ")", ")", ")", "output_operand_lossage", "(", "\"cannot decompose address\"", ")", ";", "if", "(", "ad", ".", "disp", ")", "output_addr_const", "(", "file", ",", "ad", ".", "disp", ")", ";", "else", "fprintf", "(", "file", ",", "\"0\"", ")", ";", "if", "(", "ad", ".", "base", "&&", "ad", ".", "indx", ")", "fprintf", "(", "file", ",", "\"(%s,%s)\"", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "indx", ")", "]", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "else", "if", "(", "ad", ".", "base", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "s390", "\"cannot decompose address\"", "\"0\"", "\"(%s,%s)\"", "\"(%s)\"" ]

[]

[ "<s>", "void", "BPFInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "BPF", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BPF", "::", "MOV_rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::GPRRegClass", "BPF::MOV_rr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "if", "(", "PPCSubTarget", ".", "isDarwin", "(", ")", ")", "return", "4", ";", "unsigned", "Align", "=", "PPCSubTarget", ".", "isPPC64", "(", ")", "?", "8", ":", "4", ";", "if", "(", "PPCSubTarget", ".", "hasAltivec", "(", ")", "||", "PPCSubTarget", ".", "hasQPX", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ",", "PPCSubTarget", ".", "hasQPX", "(", ")", "?", "32", ":", "16", ")", ";", "return", "Align", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "PowerPC", "PPC", "PPC", "4", "PPC", "PPC", "8", "4", "PPC", "PPC", "PPC", "32", "16" ]

[]