Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "initialize", "(", "Attributor", "&", "A", ")", "override", "{", "Function", "*", "F", "=", "getAssociatedFunction", "(", ")", ";", "auto", "&", "InfoCache", "=", "static_cast", "<", "AMDGPUInformationCache", "&", ">", "(", "A", ".", "getInfoCache", "(", ")", ")", ";", "unsigned", "MinGroupSize", ",", "MaxGroupSize", ";", "std", "::", "tie", "(", "MinGroupSize", ",", "MaxGroupSize", ")", "=", "InfoCache", ".", "getFlatWorkGroupSizes", "(", "*", "F", ")", ";", "intersectKnown", "(", "ConstantRange", "(", "APInt", "(", "32", ",", "MinGroupSize", ")", ",", "APInt", "(", "32", ",", "MaxGroupSize", "+", "1", ")", ")", ")", ";", "if", "(", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", "->", "getCallingConv", "(", ")", ")", ")", "indicatePessimisticFixpoint", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "32", "32", "1", "AMDGPU::isEntryFunctionCC" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", "&&", "!", "SIInstrInfo", "::", "isFLATScratch", "(", "*", "MI", ")", ")", "return", "false", ";", "int64_t", "NewOffset", "=", "Offset", "+", "getScratchInstrOffset", "(", "MI", ")", ";", "if", "(", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "NewOffset", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "return", "TII", "->", "isLegalFLATOffset", "(", "NewOffset", ",", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "true", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind\"", ")", ";", "case", "AMDGPU", "::", "fixup_si_sopp_br", ":", "{", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "(", "Value", "-", "4", ")", "/", "4", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_rodata", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_end_of_text", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", "+", "4", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "\"Unknown fixup kind\"", "4", "4", "4" ]

[]

[ "<s>", "static", "rtx", "aarch64_replace_reg_mode", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "mode", ")", "return", "x", ";", "x", "=", "shallow_copy_rtx", "(", "x", ")", ";", "set_mode_and_regno", "(", "x", ",", "mode", ",", "REGNO", "(", "x", ")", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Return", "a", "copy", "of", "X", "with", "mode", "MODE", ",", "without", "changing", "its", "other", "attributes", ".", "Unlike", "gen_lowpart", ",", "this", "does", "n't", "care", "whether", "the", "mode", "change", "is", "valid", "." ]

[ "aarch64" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "PIC16TargetLowering", "::", "findRepresentativeClass", "(", "EVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "i16", ":", "return", "std", "::", "make_pair", "(", "PIC16", "::", "FSR16RegisterClass", ",", "1", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "PIC16", "PIC16", "MVT::i16", "PIC16::FSR16RegisterClass", "1" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "int", "incoming", ",", "int", "libcall", ",", "int", "n_named_args", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "machine_mode", "return_mode", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cumulative", ";", "*", "cum", "=", "zero_cumulative", ";", "cum", "->", "words", "=", "0", ";", "cum", "->", "fregno", "=", "FP_ARG_MIN_REG", ";", "cum", "->", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "cum", "->", "prototype", "=", "(", "fntype", "&&", "prototype_p", "(", "fntype", ")", ")", ";", "cum", "->", "call_cookie", "=", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "libcall", ")", "?", "CALL_LIBCALL", ":", "CALL_NORMAL", ")", ";", "cum", "->", "sysv_gregno", "=", "GP_ARG_MIN_REG", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "libcall", "=", "libcall", ";", "cum", "->", "nargs_prototype", "=", "0", ";", "if", "(", "incoming", "||", "cum", "->", "prototype", ")", "cum", "->", "nargs_prototype", "=", "n_named_args", ";", "if", "(", "(", "!", "fntype", "&&", "rs6000_default_long_calls", ")", "||", "(", "fntype", "&&", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "&&", "!", "lookup_attribute", "(", "\"shortcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", ")", "cum", "->", "call_cookie", "|=", "CALL_LONG", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args:\"", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\" ret code = %s,\"", ",", "get_tree_code_name", "(", "TREE_CODE", "(", "ret_type", ")", ")", ")", ";", "}", "if", "(", "cum", "->", "call_cookie", "&", "CALL_LONG", ")", "fprintf", "(", "stderr", ",", "\" longcall,\"", ")", ";", "fprintf", "(", "stderr", ",", "\" proto = %d, nargs = %d\\n\"", ",", "cum", "->", "prototype", ",", "cum", "->", "nargs_prototype", ")", ";", "}", "if", "(", "TARGET_ELF", "&&", "(", "TARGET_64BIT", "||", "DEFAULT_ABI", "==", "ABI_V4", ")", ")", "{", "cum", "->", "escapes", "=", "call_ABI_of_interest", "(", "fndecl", ")", ";", "if", "(", "cum", "->", "escapes", ")", "{", "tree", "return_type", ";", "if", "(", "fntype", ")", "{", "return_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "else", "return_type", "=", "lang_hooks", ".", "types", ".", "type_for_mode", "(", "return_mode", ",", "0", ")", ";", "if", "(", "return_type", "!=", "NULL", ")", "{", "if", "(", "TREE_CODE", "(", "return_type", ")", "==", "RECORD_TYPE", "&&", "TYPE_TRANSPARENT_AGGR", "(", "return_type", ")", ")", "{", "return_type", "=", "TREE_TYPE", "(", "first_field", "(", "return_type", ")", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "if", "(", "AGGREGATE_TYPE_P", "(", "return_type", ")", "&&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "return_type", ")", "<=", "8", ")", ")", "rs6000_returns_struct", "=", "true", ";", "}", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "return_mode", ")", ")", "{", "rs6000_passes_float", "=", "true", ";", "if", "(", "(", "HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE", "||", "TARGET_64BIT", ")", "&&", "(", "FLOAT128_IBM_P", "(", "return_mode", ")", "||", "FLOAT128_IEEE_P", "(", "return_mode", ")", "||", "(", "return_type", "!=", "NULL", "&&", "(", "TYPE_MAIN_VARIANT", "(", "return_type", ")", "==", "long_double_type_node", ")", ")", ")", ")", "rs6000_passes_long_double", "=", "true", ";", "}", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "return_mode", ")", "||", "PAIRED_VECTOR_MODE", "(", "return_mode", ")", ")", "rs6000_passes_vector", "=", "true", ";", "}", "}", "if", "(", "fntype", "&&", "!", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", ")", "{", "error", "(", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use %qs\"", "\" to enable them\"", ",", "\"-maltivec\"", ")", ";", "}", "}", "</s>" ]

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

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"", "\"\\ninit_cumulative_args:\"", "\" ret code = %s,\"", "\" longcall,\"", "\" proto = %d, nargs = %d\\n\"", "0", "8", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use %qs\"", "\" to enable them\"", "\"-maltivec\"" ]

[]

[ "<s>", "static", "void", "rs6000_emit_move_from_cr", "(", "rtx", "reg", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "TARGET_MFCRF", ")", "{", "int", "i", ",", "cr_reg", "[", "8", "]", ",", "count", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "cr_reg", "[", "count", "++", "]", "=", "i", ";", "if", "(", "count", "==", "1", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "1", ")", ";", "rtvec", "r", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "r", ",", "0", ")", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "cr_reg", "[", "0", "]", ")", ";", "RTVEC_ELT", "(", "r", ",", "1", ")", "=", "GEN_INT", "(", "1", "<<", "(", "7", "-", "cr_reg", "[", "0", "]", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "r", ",", "UNSPEC_MOVESI_FROM_CR", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "return", ";", "}", "}", "emit_insn", "(", "gen_movesi_from_cr", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "store", "CR", "fields", "that", "need", "to", "be", "saved", "into", "REG", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "*", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "if", "(", "Reg", "==", "TRI", ".", "getFrameRegister", "(", "MF", ")", "&&", "SplitLIs", ".", "size", "(", ")", ">", "0", ")", "{", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "setFrameBaseVreg", "(", "SplitLIs", ".", "back", "(", ")", "->", "reg", ")", ";", "}", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "auto", "MII", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "MIE", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "isImplicitDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "WebAssembly", "0", "WebAssembly", "0", "0" ]

[]

[ "<s>", "inline", "bool", "function_base", "::", "apply_vl_p", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "We", "choose", "to", "apply", "vl", "operand", "by", "default", "since", "most", "of", "the", "intrinsics", "has", "vl", "operand", "." ]

[ "riscv" ]

[]

[ "<s>", "HOST_WIDE_INT", "loongarch_debugger_offset", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "offset2", "=", "const0_rtx", ";", "rtx", "reg", "=", "eliminate_constant_term", "(", "addr", ",", "&", "offset2", ")", ";", "if", "(", "offset", "==", "0", ")", "offset", "=", "INTVAL", "(", "offset2", ")", ";", "if", "(", "reg", "==", "stack_pointer_rtx", "||", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "offset", "-=", "cfun", "->", "machine", "->", "frame", ".", "total_size", ";", "if", "(", "reg", "==", "hard_frame_pointer_rtx", ")", "offset", "+=", "cfun", "->", "machine", "->", "frame", ".", "hard_frame_pointer_offset", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "The", "LoongArch", "debug", "format", "wants", "all", "automatic", "variables", "and", "arguments", "to", "be", "in", "terms", "of", "the", "virtual", "frame", "pointer", "(", "stack", "pointer", "before", "any", "adjustment", "in", "the", "function", ")", ",", "while", "the", "LoongArch", "linker", "wants", "the", "frame", "pointer", "to", "be", "the", "stack", "pointer", "after", "the", "initial", "adjustment", ".", "So", ",", "we", "do", "the", "adjustment", "here", ".", "The", "arg", "pointer", "(", "which", "is", "eliminated", ")", "points", "to", "the", "virtual", "frame", "pointer", ",", "while", "the", "frame", "pointer", "(", "which", "may", "be", "eliminated", ")", "points", "to", "the", "stack", "pointer", "after", "the", "initial", "adjustments", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "MachineInstr", "*", "DLXInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

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

[ "Returns", "true", "if", "the", "function", "contains", "a", "tail", "call", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "rl78_alloc_physical_registers_ro1", "(", "rtx_insn", "*", "insn", ")", "{", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "BC", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "OP", "(", "0", ")", "=", "move_to_acc", "(", "0", ",", "insn", ")", ";", "MUST_BE_OK", "(", "insn", ")", ";", "}", "</s>" ]

[ "Devirtualize", "an", "insn", "of", "the", "form", "SET", "(", "PC", ")", "(", "MEM/REG", ")", "." ]

[ "rl78", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "Thumb2InstrInfo", "::", "isLegalToSplitMBBAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "while", "(", "MBBI", "->", "isDebugInstr", "(", ")", ")", "{", "++", "MBBI", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "}", "Register", "PredReg", ";", "return", "getITInstrPredicate", "(", "*", "MBBI", ",", "PredReg", ")", "==", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "legal", "to", "split", "the", "given", "basic", "block", "at", "the", "specified", "instruction", "(", "i.e", "." ]

[ "ARM", "ARMCC::AL" ]

[]

[ "<s>", "bool", "PatmosSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "ANTIDEP_NONE", ";", "return", "hasPostRAScheduler", "(", "OptLevel", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "unsigned", "TPCInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "Count", ";", "MBB", ".", "erase", "(", "&", "MBB", ".", "back", "(", ")", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "0" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", ")", "const", "{", "if", "(", "LdSt", ".", "getNumOperands", "(", ")", "!=", "4", ")", "return", "false", ";", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "||", "!", "(", "LdSt", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "LdSt", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "LPAC", "::", "ADD", ")", ")", "return", "false", ";", "switch", "(", "LdSt", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Lanai", "::", "LDW_RI", ":", "case", "Lanai", "::", "LDW_RR", ":", "case", "Lanai", "::", "SW_RR", ":", "case", "Lanai", "::", "SW_RI", ":", "Width", "=", "4", ";", "break", ";", "case", "Lanai", "::", "LDHs_RI", ":", "case", "Lanai", "::", "LDHz_RI", ":", "case", "Lanai", "::", "STH_RI", ":", "Width", "=", "2", ";", "break", ";", "case", "Lanai", "::", "LDBs_RI", ":", "case", "Lanai", "::", "LDBz_RI", ":", "case", "Lanai", "::", "STB_RI", ":", "Width", "=", "1", ";", "break", ";", "}", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "4", "1", "2", "3", "3", "Lanai::LDW_RI", "Lanai::LDW_RR", "Lanai::SW_RR", "Lanai::SW_RI", "4", "Lanai::LDHs_RI", "Lanai::LDHz_RI", "Lanai::STH_RI", "2", "Lanai::LDBs_RI", "Lanai::LDBz_RI", "Lanai::STB_RI", "1", "1", "2" ]

[]

[ "<s>", "BTFTypeDerived", "::", "BTFTypeDerived", "(", "const", "DIDerivedType", "*", "DTy", ",", "unsigned", "Tag", ")", ":", "DTy", "(", "DTy", ")", "{", "switch", "(", "Tag", ")", "{", "case", "dwarf", "::", "DW_TAG_pointer_type", ":", "Kind", "=", "BTF", "::", "BTF_KIND_PTR", ";", "break", ";", "case", "dwarf", "::", "DW_TAG_const_type", ":", "Kind", "=", "BTF", "::", "BTF_KIND_CONST", ";", "break", ";", "case", "dwarf", "::", "DW_TAG_volatile_type", ":", "Kind", "=", "BTF", "::", "BTF_KIND_VOLATILE", ";", "break", ";", "case", "dwarf", "::", "DW_TAG_typedef", ":", "Kind", "=", "BTF", "::", "BTF_KIND_TYPEDEF", ";", "break", ";", "case", "dwarf", "::", "DW_TAG_restrict_type", ":", "Kind", "=", "BTF", "::", "BTF_KIND_RESTRICT", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown DIDerivedType Tag\"", ")", ";", "}", "BTFType", ".", "Info", "=", "Kind", "<<", "24", ";", "}", "</s>" ]

[ "Used", "by", "DW_TAG_pointer_type", "only", "." ]

[ "BPF", "BTF::BTF_KIND_PTR", "BTF::BTF_KIND_CONST", "BTF::BTF_KIND_VOLATILE", "BTF::BTF_KIND_TYPEDEF", "BTF::BTF_KIND_RESTRICT", "\"Unknown DIDerivedType Tag\"", "24" ]

[]

[ "<s>", "const", "char", "*", "nvptx_ptx_type_from_mode", "(", "machine_mode", "mode", ",", "bool", "promote", ")", "{", "switch", "(", "mode", ")", "{", "case", "BLKmode", ":", "return", "\".b8\"", ";", "case", "BImode", ":", "return", "\".pred\"", ";", "case", "QImode", ":", "if", "(", "promote", ")", "return", "\".u32\"", ";", "else", "return", "\".u8\"", ";", "case", "HImode", ":", "return", "\".u16\"", ";", "case", "SImode", ":", "return", "\".u32\"", ";", "case", "DImode", ":", "return", "\".u64\"", ";", "case", "SFmode", ":", "return", "\".f32\"", ";", "case", "DFmode", ":", "return", "\".f64\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "ptx", "type", "for", "MODE", ".", "If", "PROMOTE", ",", "then", "use", ".u32", "for", "QImode", "to", "deal", "with", "ptx", "ideosyncracies", "." ]

[ "nvptx", "\".b8\"", "\".pred\"", "\".u32\"", "\".u8\"", "\".u16\"", "\".u32\"", "\".u64\"", "\".f32\"", "\".f64\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "TeakRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Teak", "::", "ABRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "&", "Teak", "::", "ABRegsRegClass", ";", "if", "(", "Teak", "::", "RegNoBRegs16_nohRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "&", "Teak", "::", "RegNoBRegs16_nohRegClass", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "Teak", "Teak", "Teak::ABRegsRegClass", "Teak::ABRegsRegClass", "Teak::RegNoBRegs16_nohRegClass", "Teak::RegNoBRegs16_nohRegClass" ]

[]

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

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

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

[]

[ "<s>", "MCFixupKindInfo", "const", "&", "AVRAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "AVR", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_7_pcrel\"", ",", "3", ",", "7", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_13_pcrel\"", ",", "0", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pm\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_call\"", ",", "0", ",", "22", ",", "0", "}", ",", "{", "\"fixup_6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_6_adiw\"", ",", "0", ",", "6", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_lo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hi8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hlo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_diff8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_diff16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_diff32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_lds_sts_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port5\"", ",", "3", ",", "5", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "AVR", "AVR", "AVR::NumTargetFixupKinds", "\"fixup_32\"", "0", "32", "0", "\"fixup_7_pcrel\"", "3", "7", "\"fixup_13_pcrel\"", "0", "12", "\"fixup_16\"", "0", "16", "0", "\"fixup_16_pm\"", "0", "16", "0", "\"fixup_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi\"", "0", "8", "0", "\"fixup_hi8_ldi\"", "0", "8", "0", "\"fixup_hh8_ldi\"", "0", "8", "0", "\"fixup_ms8_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_neg\"", "0", "8", "0", "\"fixup_ms8_ldi_neg\"", "0", "8", "0", "\"fixup_lo8_ldi_pm\"", "0", "8", "0", "\"fixup_hi8_ldi_pm\"", "0", "8", "0", "\"fixup_hh8_ldi_pm\"", "0", "8", "0", "\"fixup_lo8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_call\"", "0", "22", "0", "\"fixup_6\"", "0", "16", "0", "\"fixup_6_adiw\"", "0", "6", "0", "\"fixup_lo8_ldi_gs\"", "0", "8", "0", "\"fixup_hi8_ldi_gs\"", "0", "8", "0", "\"fixup_8\"", "0", "8", "0", "\"fixup_8_lo8\"", "0", "8", "0", "\"fixup_8_hi8\"", "0", "8", "0", "\"fixup_8_hlo8\"", "0", "8", "0", "\"fixup_diff8\"", "0", "8", "0", "\"fixup_diff16\"", "0", "16", "0", "\"fixup_diff32\"", "0", "32", "0", "\"fixup_lds_sts_16\"", "0", "16", "0", "\"fixup_port6\"", "0", "16", "0", "\"fixup_port5\"", "3", "5", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "SDValue", "XNCMTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "doesNotRet", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "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", ")", ";", "}", "}", "</s>" ]

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

[ "XNCM", "XNCM", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "bool", "X86IndirectBranchTrackingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "SubTarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "auto", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "Metadata", "*", "isCFProtectionSupported", "=", "MMI", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "Metadata", "*", "FineIBT", "=", "MMI", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-fine\"", ")", ";", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "bool", "isJITwithCET", "=", "TM", "->", "isJIT", "(", ")", ";", "bool", "isJITwithCET", "=", "false", ";", "if", "(", "!", "isCFProtectionSupported", "&&", "!", "IndirectBranchTracking", "&&", "!", "isJITwithCET", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "if", "(", "FineIBT", ")", "{", "Changed", "|=", "applyFineIBT", "(", "MF", ")", ";", "FixICalls", "(", "MF", ")", ";", "FixDCalls", "(", "MF", ")", ";", "}", "else", "{", "Changed", "|=", "applyCoarseIBT", "(", "MF", ")", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCall", "(", ")", "&&", "IsCallReturnTwice", "(", "I", "->", "getOperand", "(", "0", ")", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "}", "if", "(", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "SjLj", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "MBB", ".", "isEHPad", "(", ")", ")", "{", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "I", ")", ";", "break", ";", "}", "else", "if", "(", "I", "->", "isEHLabel", "(", ")", ")", "{", "MCSymbol", "*", "Sym", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMCSymbol", "(", ")", ";", "if", "(", "!", "MF", ".", "hasCallSiteLandingPad", "(", "Sym", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "else", "if", "(", "MBB", ".", "isEHPad", "(", ")", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "isEHLabel", "(", ")", ")", "continue", ";", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"cf-protection-branch\"", "\"cf-protection-fine\"", "X86", "X86", "X86::ENDBR64", "X86::ENDBR32", "0", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", ")", "{", "if", "(", "OptExecMaskPreRA", ")", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFormMemoryClausesID", ")", ";", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "SIPreAllocateWWMRegsID", ",", "false", ")", ";", "if", "(", "EnableDCEInRA", ")", "insertPass", "(", "&", "DetectDeadLanesID", ",", "&", "DeadMachineInstructionElimID", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "CSKYAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "||", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "STQ32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R4", "||", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R7", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"Register sequence is not valid. 'r4-r7' expected\"", ")", ";", "}", "Inst", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "?", "CSKY", "::", "LDM32", ":", "CSKY", "::", "STM32", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "SEXT32", "||", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "ZEXT32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "INS32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "IDLY32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ">", "32", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "<", "0", ")", "return", "Error", "(", "IDLoc", ",", "\"n must be in range [0,32]\"", ")", ";", "}", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "CSKY", "CSKY", "CSKY::LDQ32", "CSKY::STQ32", "1", "CSKY::R4", "2", "CSKY::R7", "\"Register sequence is not valid. 'r4-r7' expected\"", "CSKY::LDQ32", "CSKY::LDM32", "CSKY::STM32", "CSKY::SEXT32", "CSKY::ZEXT32", "2", "3", "\"msb must be greater or equal to lsb\"", "CSKY::INS32", "3", "4", "\"msb must be greater or equal to lsb\"", "CSKY::IDLY32", "0", "32", "0", "0", "\"n must be in range [0,32]\"" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "GetMemOperand", "(", "MBB", ",", "FI", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Mips", "::", "LwRxSpImmX16", ";", "assert", "(", "Opc", "&&", "\"Register class not handled!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::CPU16RegsRegClass", "Mips::LwRxSpImmX16", "\"Register class not handled!\"", "0" ]

[]

[ "<s>", "void", "M68kAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Inst", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "256", "\"\\n\"", "\"unexpected instruction to relax: \"" ]

[]

[ "<s>", "static", "int", "do_reorder_for_imul", "(", "rtx_insn", "*", "*", "ready", ",", "int", "n_ready", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "set", ",", "insn1", ",", "insn2", ";", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "int", "index", "=", "-", "1", ";", "int", "i", ";", "if", "(", "!", "TARGET_CPU_P", "(", "BONNELL", ")", ")", "return", "index", ";", "insn", "=", "ready", "[", "n_ready", "-", "1", "]", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "return", "index", ";", "if", "(", "!", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "MULT", "&&", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "SImode", ")", ")", "return", "index", ";", "for", "(", "i", "=", "n_ready", "-", "2", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "insn", "=", "ready", "[", "i", "]", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "insn2", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn2", ")", "==", "PARALLEL", ")", "insn2", "=", "XVECEXP", "(", "insn2", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "insn2", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "insn2", ")", ")", "==", "MULT", "&&", "GET_MODE", "(", "SET_SRC", "(", "insn2", ")", ")", "==", "SImode", ")", "continue", ";", "FOR_EACH_DEP", "(", "insn", ",", "SD_LIST_FORW", ",", "sd_it", ",", "dep", ")", "{", "rtx", "con", ";", "con", "=", "DEP_CON", "(", "dep", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "con", ")", ")", "continue", ";", "insn1", "=", "PATTERN", "(", "con", ")", ";", "if", "(", "GET_CODE", "(", "insn1", ")", "==", "PARALLEL", ")", "insn1", "=", "XVECEXP", "(", "insn1", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "insn1", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "insn1", ")", ")", "==", "MULT", "&&", "GET_MODE", "(", "SET_SRC", "(", "insn1", ")", ")", "==", "SImode", ")", "{", "sd_iterator_def", "sd_it1", ";", "dep_t", "dep1", ";", "index", "=", "i", ";", "FOR_EACH_DEP", "(", "con", ",", "SD_LIST_BACK", ",", "sd_it1", ",", "dep1", ")", "{", "rtx", "pro", ";", "pro", "=", "DEP_PRO", "(", "dep1", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "pro", ")", ")", "continue", ";", "if", "(", "pro", "!=", "insn", ")", "index", "=", "-", "1", ";", "}", "if", "(", "index", ">=", "0", ")", "break", ";", "}", "}", "if", "(", "index", ">=", "0", ")", "break", ";", "}", "return", "index", ";", "}", "</s>" ]

[ "Try", "to", "reorder", "ready", "list", "to", "take", "advantage", "of", "Atom", "pipelined", "IMUL", "execution", ".", "It", "is", "applied", "if", "(", "1", ")", "IMUL", "instruction", "is", "on", "the", "top", "of", "list", ";", "(", "2", ")", "There", "exists", "the", "only", "producer", "of", "independent", "IMUL", "instruction", "in", "ready", "list", ".", "Return", "index", "of", "IMUL", "producer", "if", "it", "was", "found", "and", "-1", "otherwise", "." ]

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

[]

[ "<s>", "void", "tool_cleanup", "(", "bool", "from_signal", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ptx_cfile_name", ")", "maybe_unlink", "(", "ptx_cfile_name", ")", ";", "if", "(", "ptx_name", ")", "maybe_unlink", "(", "ptx_name", ")", ";", "}", "</s>" ]

[ "Delete", "tempfiles", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "parseExpression", "(", "MCExpr", "const", "*", "&", "Expr", ")", "{", "SmallVector", "<", "AsmToken", ",", "4", ">", "Tokens", ";", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "bool", "Done", "=", "false", ";", "static", "char", "const", "*", "Comma", "=", "\",\"", ";", "do", "{", "Tokens", ".", "emplace_back", "(", "Lexer", ".", "getTok", "(", ")", ")", ";", "Lex", "(", ")", ";", "switch", "(", "Tokens", ".", "back", "(", ")", ".", "getKind", "(", ")", ")", "{", "case", "AsmToken", "::", "TokenKind", "::", "Hash", ":", "if", "(", "Tokens", ".", "size", "(", ")", ">", "1", ")", "if", "(", "(", "Tokens", ".", "end", "(", ")", "-", "2", ")", "->", "getKind", "(", ")", "==", "AsmToken", "::", "TokenKind", "::", "Plus", ")", "{", "Tokens", ".", "insert", "(", "Tokens", ".", "end", "(", ")", "-", "2", ",", "AsmToken", "(", "AsmToken", "::", "TokenKind", "::", "Comma", ",", "Comma", ")", ")", ";", "Done", "=", "true", ";", "}", "break", ";", "case", "AsmToken", "::", "TokenKind", "::", "RCurly", ":", "case", "AsmToken", "::", "TokenKind", "::", "EndOfStatement", ":", "case", "AsmToken", "::", "TokenKind", "::", "Eof", ":", "Done", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "while", "(", "!", "Done", ")", ";", "while", "(", "!", "Tokens", ".", "empty", "(", ")", ")", "{", "Lexer", ".", "UnLex", "(", "Tokens", ".", "back", "(", ")", ")", ";", "Tokens", ".", "pop_back", "(", ")", ";", "}", "return", "getParser", "(", ")", ".", "parseExpression", "(", "Expr", ")", ";", "}", "</s>" ]

[ "Parse", "an", "arbitrary", "expression", "." ]

[ "Hexagon", "Hexagon", "4", "\",\"", "1", "2", "2" ]

[]

[ "<s>", "static", "bool", "rs6000_valid_attribute_p", "(", "tree", "fndecl", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "args", ",", "int", "flags", ")", "{", "struct", "cl_target_option", "cur_target", ";", "bool", "ret", ";", "tree", "old_optimize", ";", "tree", "new_target", ",", "new_optimize", ";", "tree", "func_optimize", ";", "gcc_assert", "(", "(", "fndecl", "!=", "NULL_TREE", ")", "&&", "(", "args", "!=", "NULL_TREE", ")", ")", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "tree", "tname", "=", "DECL_NAME", "(", "fndecl", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_valid_attribute_p:\\n\"", ")", ";", "if", "(", "tname", ")", "fprintf", "(", "stderr", ",", "\"function: %.*s\\n\"", ",", "(", "int", ")", "IDENTIFIER_LENGTH", "(", "tname", ")", ",", "IDENTIFIER_POINTER", "(", "tname", ")", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"function: unknown\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"args:\"", ")", ";", "rs6000_debug_target_options", "(", "args", ",", "\" \"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "flags", ")", "fprintf", "(", "stderr", ",", "\"flags: 0x%x\\n\"", ",", "flags", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", "&&", "TREE_CHAIN", "(", "args", ")", "==", "NULL_TREE", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ",", "\"default\"", ")", "==", "0", ")", "return", "true", ";", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "func_optimize", "&&", "func_optimize", "!=", "old_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_save", "(", "&", "cur_target", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "1", ";", "ret", "=", "rs6000_inner_target_options", "(", "args", ",", "true", ")", ";", "if", "(", "ret", ")", "{", "ret", "=", "rs6000_option_override_internal", "(", "false", ")", ";", "new_target", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "else", "new_target", "=", "NULL", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "!", "new_target", ")", "ret", "=", "false", ";", "else", "if", "(", "fndecl", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "cur_target", ")", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_OPTIMIZATION", "(", "old_optimize", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "attribute", "(", "(", "target", "(", "``", "...", "''", ")", ")", ")", "." ]

[ "rs6000", "\"\\n==================== rs6000_valid_attribute_p:\\n\"", "\"function: %.*s\\n\"", "\"function: unknown\\n\"", "\"args:\"", "\" \"", "\"\\n\"", "\"flags: 0x%x\\n\"", "\"--------------------\\n\"", "\"default\"", "0", "1" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequiredID", "(", "LoopSimplifyID", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"X86ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\"Base_Reg \"", ";", "if", "(", "Base_Reg", ".", "getNode", "(", ")", ")", "Base_Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base_FrameIndex", "<<", "'\\n'", "<<", "\" Scale\"", "<<", "Scale", "<<", "'\\n'", "<<", "\"IndexReg \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", "<<", "\"GV \"", ";", "if", "(", "GV", ")", "GV", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" CP \"", ";", "if", "(", "CP", ")", "CP", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "'\\n'", "<<", "\"ES \"", ";", "if", "(", "ES", ")", "dbgs", "(", ")", "<<", "ES", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" MCSym \"", ";", "if", "(", "MCSym", ")", "dbgs", "(", ")", "<<", "MCSym", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "X86", "\"X86ISelAddressMode \"", "\"Base_Reg \"", "\"nul\"", "\" Base.FrameIndex \"", "\" Scale\"", "\"IndexReg \"", "\"nul\"", "\" Disp \"", "\"GV \"", "\"nul\"", "\" CP \"", "\"nul\"", "\"ES \"", "\"nul\"", "\" MCSym \"", "\"nul\"", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::INTRINSIC_WO_CHAIN", "\"unimplemented operand\"" ]

[]

[ "<s>", "int", "check_pic", "(", "int", "i", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "gcc_assert", "(", "GET_CODE", "(", "recog_data", ".", "operand", "[", "i", "]", ")", "!=", "SYMBOL_REF", "&&", "(", "GET_CODE", "(", "recog_data", ".", "operand", "[", "i", "]", ")", "!=", "CONST", "||", "(", "GET_CODE", "(", "XEXP", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "0", ")", ")", "==", "MINUS", "&&", "(", "XEXP", "(", "XEXP", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "0", ")", ",", "0", ")", "==", "global_offset_table", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "0", ")", ",", "1", ")", ")", "==", "CONST", ")", ")", ")", ")", ";", "case", "2", ":", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Ensure", "that", "we", "are", "not", "using", "patterns", "that", "are", "not", "OK", "with", "PIC", "." ]

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isTruncateFree", "(", "EVT", "SrcVT", ",", "EVT", "DstVT", ")", "const", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "||", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", "||", "!", "SrcVT", ".", "isInteger", "(", ")", "||", "!", "DstVT", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "SrcBits", "=", "SrcVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "DestBits", "=", "DstVT", ".", "getSizeInBits", "(", ")", ";", "return", "(", "SrcBits", "==", "64", "&&", "DestBits", "==", "32", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "64", "32" ]

[]

[ "<s>", "static", "void", "mips_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "const", "char", "*", "fnname", ";", "HOST_WIDE_INT", "tsize", "=", "cfun", "->", "machine", "->", "frame", ".", "total_size", ";", "if", "(", "debug_info_level", "!=", "DINFO_LEVEL_TERSE", "&&", "write_symbols", "==", "SDB_DEBUG", ")", "SDB_OUTPUT_SOURCE_LINE", "(", "file", ",", "DECL_SOURCE_LINE", "(", "current_function_decl", ")", ")", ";", "if", "(", "TARGET_MIPS16", "&&", "!", "TARGET_SOFT_FLOAT", "&&", "current_function_args_info", ".", "fp_code", "!=", "0", ")", "build_mips16_function_stub", "(", "file", ")", ";", "if", "(", "!", "FUNCTION_NAME_ALREADY_DECLARED", ")", "{", "fnname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.ent\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "}", "assemble_name", "(", "file", ",", "fnname", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "}", "if", "(", "TARGET_IRIX", "&&", "mips_abi", "==", "ABI_32", ")", "TREE_ASM_WRITTEN", "(", "DECL_NAME", "(", "cfun", "->", "decl", ")", ")", "=", "1", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "fprintf", "(", "file", ",", "\"\\t.frame\\t%s,\"", "HOST_WIDE_INT_PRINT_DEC", "\",%s\\t\\t\"", "\"# vars= \"", "HOST_WIDE_INT_PRINT_DEC", "\", regs= %d/%d\"", "\", args= \"", "HOST_WIDE_INT_PRINT_DEC", "\", gp= \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "(", "reg_names", "[", "(", "frame_pointer_needed", ")", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", "]", ")", ",", "(", "(", "frame_pointer_needed", "&&", "TARGET_MIPS16", ")", "?", "tsize", "-", "cfun", "->", "machine", "->", "frame", ".", "args_size", ":", "tsize", ")", ",", "reg_names", "[", "GP_REG_FIRST", "+", "31", "]", ",", "cfun", "->", "machine", "->", "frame", ".", "var_size", ",", "cfun", "->", "machine", "->", "frame", ".", "num_gp", ",", "cfun", "->", "machine", "->", "frame", ".", "num_fp", ",", "cfun", "->", "machine", "->", "frame", ".", "args_size", ",", "cfun", "->", "machine", "->", "frame", ".", "cprestore_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t.mask\\t0x%08x,\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "cfun", "->", "machine", "->", "frame", ".", "gp_save_offset", ")", ";", "fprintf", "(", "file", ",", "\"\\t.fmask\\t0x%08x,\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "cfun", "->", "machine", "->", "frame", ".", "fp_save_offset", ")", ";", "}", "if", "(", "TARGET_ABICALLS", "&&", "!", "TARGET_NEWABI", "&&", "cfun", "->", "machine", "->", "global_pointer", ">", "0", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "all_noreorder_p", ")", "output_asm_insn", "(", "\"%(.cpload\\t%^%)\"", ",", "0", ")", ";", "else", "output_asm_insn", "(", "\"%(.cpload\\t%^\\n\\t%<\"", ",", "0", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "all_noreorder_p", ")", "output_asm_insn", "(", "\"%(%<\"", ",", "0", ")", ";", "mips_output_cplocal", "(", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "mips", "0", "0", "0", "\"\\t.ent\\t\"", "\"\\n\"", "\":\\n\"", "1", "\"\\t.frame\\t%s,\"", "\",%s\\t\\t\"", "\"# vars= \"", "\", regs= %d/%d\"", "\", args= \"", "\", gp= \"", "\"\\n\"", "31", "\"\\t.mask\\t0x%08x,\"", "\"\\n\"", "\"\\t.fmask\\t0x%08x,\"", "\"\\n\"", "0", "\"%(.cpload\\t%^%)\"", "0", "\"%(.cpload\\t%^\\n\\t%<\"", "0", "\"%(%<\"", "0" ]

[]

[ "<s>", "bool", "SystemZXPLINKFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "SystemZ", "::", "GPRRegs", "SpillGPRs", "=", "ZFI", "->", "getSpillGPRRegs", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "SpillGPRs", ".", "LowGPR", ")", "{", "assert", "(", "SpillGPRs", ".", "LowGPR", "!=", "SpillGPRs", ".", "HighGPR", "&&", "\"Should be saving multiple registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "STMG", ")", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "LowGPR", ",", "false", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "SpillGPRs", ".", "HighGPR", ",", "false", ")", ";", "MIB", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ";", "MIB", ".", "addImm", "(", "SpillGPRs", ".", "GPROffset", ")", ";", "auto", "&", "GRRegClass", "=", "SystemZ", "::", "GR64BitRegClass", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "GRRegClass", ".", "contains", "(", "Reg", ")", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "Reg", ",", "true", ")", ";", "}", "}", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "I", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "}", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "I", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::GPRRegs", "\"Should be saving multiple registers\"", "SystemZ::STMG", "SystemZ::GR64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass" ]

[]

[ "<s>", "unsigned", "getRegisterType", "(", "unsigned", "Reg", ")", "const", "{", "if", "(", "RegInfo", ".", "count", "(", "Reg", ")", ")", "return", "RegInfo", ".", "lookup", "(", "Reg", ")", ".", "Type", ";", "else", "llvm_unreachable", "(", "\"Unknown register\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "of", "registers", "that", "this", "ValueType", "will", "eventually", "require", "." ]

[ "PTX", "\"Unknown register\"" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Node", "->", "getMachineOpcode", "(", ")", ")", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "if", "(", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE" ]

[]

[ "<s>", "static", "bool", "pru_nongeneric_pointer_addrspace", "(", "tree", "typ", ")", "{", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "typ", ")", ")", "typ", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "typ", ")", ")", "{", "addr_space_t", "as", ";", "tree", "target", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "FUNCTION_TYPE", "==", "TREE_CODE", "(", "target", ")", ")", "return", "pru_nongeneric_pointer_addrspace", "(", "TREE_TYPE", "(", "target", ")", ")", ";", "while", "(", "TREE_CODE", "(", "target", ")", "==", "ARRAY_TYPE", ")", "target", "=", "TREE_TYPE", "(", "target", ")", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "target", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "return", "true", ";", "return", "pru_nongeneric_pointer_addrspace", "(", "target", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Scan", "type", "TYP", "for", "pointer", "references", "to", "address", "space", "other", "than", "ADDR_SPACE_GENERIC", ".", "Return", "true", "if", "such", "reference", "is", "found", ".", "Much", "of", "this", "code", "was", "taken", "from", "the", "avr", "port", "." ]

[ "pru" ]

[]

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

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

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

[]

[ "<s>", "const", "SparcMCExpr", "*", "SparcMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "SparcMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "bool", "PPCTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createPPCBranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "X86TargetLowering", "::", "findRepresentativeClass", "(", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "0", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "(", "const", "TargetRegisterClass", "*", ")", "&", "X86", "::", "GR64RegClass", ":", "(", "const", "TargetRegisterClass", "*", ")", "&", "X86", "::", "GR32RegClass", ";", "break", ";", "case", "MVT", "::", "x86mmx", ":", "RRC", "=", "&", "X86", "::", "VR64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "RRC", "=", "&", "X86", "::", "VR128RegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "X86", "X86", "0", "1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::x86mmx", "X86::VR64RegClass", "MVT::f32", "MVT::f64", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "MVT::v32i8", "MVT::v8i32", "MVT::v4i64", "MVT::v8f32", "MVT::v4f64", "X86::VR128RegClass" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC branch opcode!\"", ")", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "Cond", "[", "0", "]", ".", "setImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "0", "?", "1", ":", "0", ")", ";", "else", "Cond", "[", "0", "]", ".", "setImm", "(", "PPC", "::", "InvertPredicate", "(", "(", "PPC", "::", "Predicate", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "2", "\"Invalid PPC branch opcode!\"", "1", "PPC::CTR8", "1", "PPC::CTR", "0", "0", "0", "1", "0", "0", "PPC::InvertPredicate", "PPC::Predicate", "0" ]

[]

[ "<s>", "void", "LoongArchInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "LoongArch", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "LoongArch", "::", "OR", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "LoongArch", "::", "R0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"LoongArch didn't implement copyPhysReg\"", ")", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "LoongArch::GPRRegClass", "LoongArch::OR", "LoongArch::R0", "\"LoongArch didn't implement copyPhysReg\"" ]

[]

[ "<s>", "bool", "LanaiMemAluCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisableMemAluCombiner", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "LanaiSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MfIterator", "MFI", "=", "MF", ".", "begin", "(", ")", ";", "MFI", "!=", "MF", ".", "end", "(", ")", ";", "++", "MFI", ")", "{", "Modified", "|=", "combineMemAluInBasicBlock", "(", "&", "*", "MFI", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "isVariadic", "(", ")", ")", "for", "(", "auto", "i", "=", "Desc", ".", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "0", ")", "OS", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "i", ",", "OS", ")", ";", "}", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\", \"" ]

[]

[ "<s>", "bool", "nds32_can_use_btgl_p", "(", "HOST_WIDE_INT", "ival", ")", "{", "int", "one_bit_count", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "SImode", ")", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "ival", ")", "&", "mask", ")", ";", "return", "(", "TARGET_EXT_PERF", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'btgl", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "unsigned", "PPCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "PPC", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsIEEEMode", "=", "ST", "->", "enableIEEEBit", "(", "MF", ")", "||", "!", "MFI", "->", "hasNoSignedZerosFPMath", "(", ")", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "depth_first", "(", "&", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "MBB", "->", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "tryFoldInst", "(", "TII", ",", "&", "MI", ")", ";", "if", "(", "!", "TII", "->", "isFoldableCopy", "(", "MI", ")", ")", "{", "if", "(", "IsIEEEMode", "||", "!", "tryFoldOMod", "(", "MI", ")", ")", "tryFoldClamp", "(", "MI", ")", ";", "continue", ";", "}", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", "||", "OpToFold", ".", "isFI", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "R600" ]

[]

[ "<s>", "static", "int", "get_base_reg", "(", "rtx", "x", ")", "{", "tree", "decl", ";", "int", "base_reg", ";", "if", "(", "!", "flag_pic", "||", "microblaze_tls_symbol_p", "(", "x", ")", ")", "base_reg", "=", "MB_ABI_BASE_REGNUM", ";", "else", "if", "(", "flag_pic", ")", "base_reg", "=", "MB_ABI_PIC_ADDR_REGNUM", ";", "if", "(", "TARGET_XLGPOPT", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "x", ")", "&&", "(", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ")", "!=", "NULL", ")", "{", "if", "(", "TREE_READONLY", "(", "decl", ")", ")", "base_reg", "=", "MB_ABI_GPRO_REGNUM", ";", "else", "base_reg", "=", "MB_ABI_GPRW_REGNUM", ";", "}", "return", "base_reg", ";", "}", "</s>" ]

[ "Get", "the", "base", "register", "for", "accessing", "a", "value", "from", "the", "memory", "or", "Symbol", "ref", ".", "Used", "for", "MicroBlaze", "Small", "Data", "Area", "Pointer", "Optimization", "." ]

[ "microblaze" ]

[]

[ "<s>", "static", "void", "visium_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "cumulative_args_t", "local_args_so_far", ";", "CUMULATIVE_ARGS", "local_copy", ";", "CUMULATIVE_ARGS", "*", "locargs", ";", "int", "gp_saved", ",", "fp_saved", ",", "size", ";", "local_args_so_far", ".", "p", "=", "&", "local_copy", ";", "locargs", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "local_args_so_far", ".", "magic", "=", "CUMULATIVE_ARGS_MAGIC", ";", "local_copy", ".", "grcount", "=", "locargs", "->", "grcount", ";", "local_copy", ".", "frcount", "=", "locargs", "->", "frcount", ";", "local_copy", ".", "stack_words", "=", "locargs", "->", "stack_words", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "TARGET_FUNCTION_ARG_ADVANCE", "(", "local_args_so_far", ",", "arg", ")", ";", "locargs", "=", "get_cumulative_args", "(", "local_args_so_far", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_GP_REGISTERS", "-", "locargs", "->", "grcount", ";", "fp_saved", "=", "(", "TARGET_FPU", "?", "MAX_ARGS_IN_FP_REGISTERS", "-", "locargs", "->", "frcount", ":", "0", ")", ";", "size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", ")", "+", "(", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ";", "if", "(", "!", "no_rtl", "&&", "size", ">", "0", ")", "{", "rtx", "ptr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "size", ")", ")", ";", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "ptr", ",", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "locargs", "->", "grcount", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "gcc_assert", "(", "UNITS_PER_WORD", "==", "UNITS_PER_HWFPVALUE", ")", ";", "move_block_from_reg", "(", "locargs", "->", "frcount", "+", "FP_ARG_FIRST", ",", "mem", ",", "fp_saved", ")", ";", "}", "}", "visium_reg_parm_save_area_size", "=", "size", ";", "}", "</s>" ]

[ "Store", "the", "anonymous", "register", "arguments", "into", "the", "stack", "so", "that", "all", "the", "arguments", "appear", "to", "have", "been", "passed", "consecutively", "on", "the", "stack", "." ]

[ "visium", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "enableInterleavedAccessVectorization", "(", ")", "{", "return", "!", "(", "ST", "->", "isAtom", "(", ")", "||", "ST", "->", "isSLM", "(", ")", ")", ";", "}", "</s>" ]

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasISEL", "(", ")", ")", "return", "false", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "false", ";", "CondCycles", "=", "1", ";", "TrueCycles", "=", "1", ";", "FalseCycles", "=", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "PowerPC", "PPC", "2", "1", "PPC::CTR", "1", "PPC::CTR8", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "1", "1", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "GBZ80RegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "GB", "::", "R8_GPRRegClass", ")", "return", "&", "GB", "::", "R8RegClass", ";", "else", "if", "(", "RC", "==", "&", "GB", "::", "R16_HLRegClass", "||", "RC", "==", "&", "GB", "::", "R16_BCDERegClass", ")", "return", "&", "GB", "::", "R16RegClass", ";", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "GBZ80", "GB", "GB::R8_GPRRegClass", "GB::R8RegClass", "GB::R16_HLRegClass", "GB::R16_BCDERegClass", "GB::R16RegClass" ]

[]

[ "<s>", "static", "bool", "is_cracked_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_YES", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_NO", ")", "||", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_NO", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_NO", ")", "||", "(", "type", "==", "TYPE_STORE", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_NO", ")", "||", "(", "(", "type", "==", "TYPE_FPLOAD", "||", "type", "==", "TYPE_FPSTORE", ")", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", ")", "||", "type", "==", "TYPE_DELAYED_CR", "||", "(", "type", "==", "TYPE_EXTS", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", ")", "||", "(", "type", "==", "TYPE_SHIFT", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", "&&", "get_attr_var_shift", "(", "insn", ")", "==", "VAR_SHIFT_NO", ")", "||", "(", "type", "==", "TYPE_MUL", "&&", "get_attr_dot", "(", "insn", ")", "==", "DOT_YES", ")", "||", "type", "==", "TYPE_DIV", "||", "(", "type", "==", "TYPE_INSERT", "&&", "get_attr_size", "(", "insn", ")", "==", "SIZE_32", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "INSN", "is", "cracked", "into", "2", "instructions", "by", "the", "processor", "(", "and", "therefore", "occupies", "2", "issue", "slots", ")", "." ]

[ "powerpcspe" ]

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "R4", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "R4", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::R4", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SP", "MSP430::R4", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "DummyBool", ";", "int", "DummyInt", ";", "unsigned", "DummyUnsigned", ";", "return", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isEXTMask", "(", "M", ",", "VT", ",", "DummyBool", ",", "DummyUnsigned", ")", "||", "isTRNMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isINSMask", "(", "M", ",", "VT", ".", "getVectorNumElements", "(", ")", ",", "DummyBool", ",", "DummyInt", ")", "||", "isConcatMask", "(", "M", ",", "VT", ",", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "0", "64", "32", "16", "128" ]

[]

[ "<s>", "static", "void", "bpf_output_constructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "symbol", ")", ";", "if", "(", "decl", ")", "sorry_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"no constructors\"", ")", ";", "else", "sorry", "(", "\"no constructors\"", ")", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "code", "for", "a", "constructor", ".", "Since", "eBPF", "does", "n't", "support", "indirect", "calls", ",", "constructors", "are", "not", "supported", "." ]

[ "bpf", "\"no constructors\"", "\"no constructors\"" ]

[]

[ "<s>", "static", "int", "h8300_monitor_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"monitor\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "a", "monitor", "function", "as", "specified", "by", "the", "``", "monitor", "''", "attribute", "." ]

[ "h8300", "0", "\"monitor\"" ]

[]

[ "<s>", "void", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "override", "{", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "AMDGPU" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_lo16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_ha16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_lo14\"", ",", "16", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_toc\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_ppc_toc16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_toc16_ds\"", ",", "16", ",", "14", ",", "0", "}", ",", "{", "\"fixup_ppc_tlsreg\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_ppc_nofixup\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "PowerPC", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_lo16\"", "16", "16", "0", "\"fixup_ppc_ha16\"", "16", "16", "0", "\"fixup_ppc_lo14\"", "16", "14", "0", "\"fixup_ppc_toc\"", "0", "64", "0", "\"fixup_ppc_toc16\"", "16", "16", "0", "\"fixup_ppc_toc16_ds\"", "16", "14", "0", "\"fixup_ppc_tlsreg\"", "0", "0", "0", "\"fixup_ppc_nofixup\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_msa_test_branch", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ")", "{", "struct", "expand_operand", "ops", "[", "3", "]", ";", "rtx_insn", "*", "cbranch", ";", "rtx_code_label", "*", "true_label", ",", "*", "done_label", ";", "rtx", "cmp_result", ";", "true_label", "=", "gen_label_rtx", "(", ")", ";", "done_label", "=", "gen_label_rtx", "(", ")", ";", "create_input_operand", "(", "&", "ops", "[", "0", "]", ",", "true_label", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ")", ";", "mips_prepare_builtin_arg", "(", "&", "ops", "[", "1", "]", ",", "exp", ",", "0", ")", ";", "create_fixed_operand", "(", "&", "ops", "[", "2", "]", ",", "const0_rtx", ")", ";", "if", "(", "GET_CODE", "(", "ops", "[", "1", "]", ".", "value", ")", "!=", "REG", ")", "ops", "[", "1", "]", ".", "value", "=", "force_reg", "(", "ops", "[", "1", "]", ".", "mode", ",", "ops", "[", "1", "]", ".", "value", ")", ";", "if", "(", "(", "cbranch", "=", "maybe_gen_insn", "(", "icode", ",", "3", ",", "ops", ")", ")", "==", "NULL_RTX", ")", "error", "(", "\"failed to expand built-in function\"", ")", ";", "cmp_result", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mips_emit_move", "(", "cmp_result", ",", "const0_rtx", ")", ";", "emit_jump_insn", "(", "cbranch", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "done_label", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "true_label", ")", ";", "mips_emit_move", "(", "cmp_result", ",", "const1_rtx", ")", ";", "emit_label", "(", "done_label", ")", ";", "return", "cmp_result", ";", "}", "</s>" ]

[ "Expand", "an", "MSA", "built-in", "for", "a", "compare", "and", "branch", "instruction", "specified", "by", "ICODE", ",", "set", "a", "general-purpose", "register", "to", "1", "if", "the", "branch", "was", "taken", ",", "0", "otherwise", "." ]

[ "mips", "3", "0", "1", "0", "2", "1", "1", "1", "1", "3", "\"failed to expand built-in function\"" ]

[]

[ "<s>", "void", "frv_expand_epilogue", "(", "bool", "emit_return", ")", "{", "frv_stack_t", "*", "info", "=", "frv_stack_info", "(", ")", ";", "rtx", "fp", "=", "frame_pointer_rtx", ";", "rtx", "sp", "=", "stack_pointer_rtx", ";", "rtx", "return_addr", ";", "int", "fp_offset", ";", "fp_offset", "=", "info", "->", "reg_offset", "[", "FRAME_POINTER_REGNUM", "]", ";", "if", "(", "!", "current_function_sp_is_unchanging", ")", "emit_insn", "(", "gen_addsi3", "(", "sp", ",", "fp", ",", "frv_frame_offset_rtx", "(", "-", "fp_offset", ")", ")", ")", ";", "frv_frame_access_standard_regs", "(", "FRV_LOAD", ",", "info", ")", ";", "if", "(", "info", "->", "save_p", "[", "LR_REGNO", "]", ")", "{", "int", "lr_offset", ";", "rtx", "mem", ";", "lr_offset", "=", "info", "->", "reg_offset", "[", "LR_REGNO", "]", ";", "if", "(", "frame_pointer_needed", ")", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "fp", ",", "lr_offset", "-", "fp_offset", ")", ";", "else", "mem", "=", "frv_frame_mem", "(", "Pmode", ",", "sp", ",", "lr_offset", ")", ";", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "TEMP_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "return_addr", ",", "mem", ")", ")", ";", "}", "else", "return_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "fp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "fp", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "fp", ")", ")", ";", "}", "if", "(", "info", "->", "total_size", "!=", "0", ")", "{", "rtx", "offset", "=", "frv_frame_offset_rtx", "(", "info", "->", "total_size", ")", ";", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "offset", ")", ")", ";", "}", "if", "(", "current_function_calls_eh_return", ")", "emit_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "emit_return", ")", "emit_jump_insn", "(", "gen_epilogue_return", "(", "return_addr", ")", ")", ";", "else", "{", "rtx", "lr", "=", "return_addr", ";", "if", "(", "REGNO", "(", "return_addr", ")", "!=", "LR_REGNO", ")", "{", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "emit_move_insn", "(", "lr", ",", "return_addr", ")", ";", "}", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "lr", ")", ")", ";", "}", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "epilogue", ".", "Using", "an", "epilogue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "target", "hook", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", "." ]

[ "frv", "0" ]

[]

[ "<s>", "static", "bool", "mips_in_small_data_p", "(", "const_tree", "decl", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TARGET_ABICALLS", "||", "TARGET_VXWORKS_RTP", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", ";", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "!=", "0", "&&", "strcmp", "(", "name", ",", "\".sbss\"", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "mips_lo_relocs", "[", "SYMBOL_GP_RELATIVE", "]", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "else", "if", "(", "TARGET_EMBEDDED_DATA", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "return", "false", ";", "}", "if", "(", "!", "TARGET_LOCAL_SDATA", "&&", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_EXTERN_SDATA", "&&", "DECL_P", "(", "decl", ")", ")", "{", "if", "(", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "DECL_COMMON", "(", "decl", ")", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "NULL", ")", "return", "false", ";", "}", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "size", ">", "0", "&&", "size", "<=", "mips_small_data_threshold", ";", "}", "</s>" ]

[ "Implement", "TARGET_IN_SMALL_DATA_P", ".", "Return", "true", "if", "it", "would", "be", "safe", "to", "access", "DECL", "using", "%", "gp_rel", "(", "...", ")", "(", "$", "gp", ")", "." ]

[ "mips", "0", "\".sdata\"", "0", "\".sbss\"", "0", "0" ]

[]

[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "restrictIT", "=", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "restrictIT", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "++", "MFI", ";", "Modified", "|=", "InsertITInstructions", "(", "MBB", ")", ";", "}", "if", "(", "Modified", ")", "AFI", "->", "setHasITBlocks", "(", "true", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

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

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

[ "cr16" ]

[]

[ "<s>", "static", "bool", "sparc_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "aligned_p", "&&", "size", "==", "8", "&&", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", ")", ")", "{", "if", "(", "TARGET_V9", ")", "{", "assemble_integer_with_op", "(", "\"\\t.xword\\t\"", ",", "x", ")", ";", "return", "true", ";", "}", "else", "{", "assemble_aligned_integer", "(", "4", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "4", ",", "x", ")", ";", "return", "true", ";", "}", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "sparc", "version", "has", "special", "handling", "for", "aligned", "DI-mode", "objects", "." ]

[ "sparc", "8", "\"\\t.xword\\t\"", "4", "4" ]

[]

[ "<s>", "bool", "detect_cmse_nonsecure_call", "(", "tree", "addr", ")", "{", "if", "(", "!", "addr", ")", "return", "FALSE", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "addr", ")", ";", "if", "(", "use_cmse", "&&", "lookup_attribute", "(", "\"cmse_nonsecure_call\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Returns", "true", "if", "-mcmse", "has", "been", "passed", "and", "the", "function", "pointed", "to", "by", "'addr", "'", "has", "the", "cmse_nonsecure_call", "attribute", "and", "returns", "false", "otherwise", "." ]

[ "arm", "\"cmse_nonsecure_call\"" ]

[]

[ "<s>", "unsigned", "X86TTI", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TargetTransformInfo", "::", "getIntImmCost", "(", "IID", ",", "Imm", ",", "Ty", ")", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "else", "return", "X86TTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "else", "return", "X86TTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "X86", "X86", "Intrinsic::ID", "0", "0U", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "64", "32", "X86", "Intrinsic::experimental_stackmap", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "64", "64", "X86" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ";", "MI", ".", "print", "(", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ";", "int", "Offset", "=", "(", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "+", "(", "-", "(", "spOffset", "+", "4", ")", ")", ")", ":", "(", "spOffset", ")", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getImm", "(", ")", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", ";", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ";", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "1" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "return", "LI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ">", "64", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsMCCodeEmitter", "::", "isMicroMips", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureMicroMips", ";", "}", "</s>" ]

[ "Check", "whether", "a", "given", "symbol", "has", "been", "flagged", "with", "MICROMIPS", "flag", "." ]

[ "Mips", "Mips", "Mips", "Mips::FeatureMicroMips" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ",", "DCI", ".", "DAG", ")", ")", "{", "if", "(", "SDValue", "V", "=", "PerformHvxDAGCombine", "(", "N", ",", "DCI", ")", ")", "return", "V", ";", "return", "SDValue", "(", ")", ";", "}", "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Op", "(", "N", ",", "0", ")", ";", "const", "SDLoc", "&", "dl", "(", "Op", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "HexagonISD", "::", "P2D", ")", "{", "SDValue", "P", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "switch", "(", "P", ".", "getOpcode", "(", ")", ")", "{", "case", "HexagonISD", "::", "PTRUE", ":", "return", "DCI", ".", "DAG", ".", "getConstant", "(", "-", "1", ",", "dl", ",", "ty", "(", "Op", ")", ")", ";", "case", "HexagonISD", "::", "PFALSE", ":", "return", "getZero", "(", "dl", ",", "ty", "(", "Op", ")", ",", "DCI", ".", "DAG", ")", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "Opc", "==", "ISD", "::", "VSELECT", ")", "{", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Cond", "->", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", ")", "{", "SDValue", "C0", "=", "Cond", ".", "getOperand", "(", "0", ")", ",", "C1", "=", "Cond", ".", "getOperand", "(", "1", ")", ";", "if", "(", "C1", "->", "getOpcode", "(", ")", "==", "HexagonISD", "::", "PTRUE", ")", "{", "SDValue", "VSel", "=", "DCI", ".", "DAG", ".", "getNode", "(", "ISD", "::", "VSELECT", ",", "dl", ",", "ty", "(", "Op", ")", ",", "C0", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "Op", ".", "getOperand", "(", "1", ")", ")", ";", "return", "VSel", ";", "}", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "HexagonISD::P2D", "0", "HexagonISD::PTRUE", "1", "HexagonISD::PFALSE", "ISD::VSELECT", "0", "ISD::XOR", "0", "1", "HexagonISD::PTRUE", "ISD::VSELECT", "2", "1" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "PowerPC", "PPC", "\"no-realign-stack\"" ]

[]

[ "<s>", "bool", "ScheduleDAGPostRA", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "{", "return", "SchedImpl", "->", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "Patmos" ]

[]

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

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

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

[]

[ "<s>", "const", "SISubtarget", "*", "GCNTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "StringRef", "GPU", "=", "getGPUName", "(", "F", ")", ";", "StringRef", "FS", "=", "getFeatureString", "(", "F", ")", ";", "SmallString", "<", "128", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "SISubtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "SIGISelActualAccessor", "*", "GISel", "=", "new", "SIGISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AMDGPUCallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "I", "->", "setScalarizeGlobalBehavior", "(", "ScalarizeGlobal", ")", ";", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Value", "*", "GCNTTIImpl", "::", "rewriteIntrinsicWithAddressSpace", "(", "IntrinsicInst", "*", "II", ",", "Value", "*", "OldV", ",", "Value", "*", "NewV", ")", "const", "{", "auto", "IntrID", "=", "II", "->", "getIntrinsicID", "(", ")", ";", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "const", "ConstantInt", "*", "IsVolatile", "=", "cast", "<", "ConstantInt", ">", "(", "II", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "IsVolatile", "->", "isZero", "(", ")", ")", "return", "nullptr", ";", "Module", "*", "M", "=", "II", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "DestTy", "=", "II", "->", "getType", "(", ")", ";", "Type", "*", "SrcTy", "=", "NewV", "->", "getType", "(", ")", ";", "Function", "*", "NewDecl", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "II", "->", "getIntrinsicID", "(", ")", ",", "{", "DestTy", ",", "SrcTy", "}", ")", ";", "II", "->", "setArgOperand", "(", "0", ",", "NewV", ")", ";", "II", "->", "setCalledFunction", "(", "NewDecl", ")", ";", "return", "II", ";", "}", "case", "Intrinsic", "::", "amdgcn_is_shared", ":", "case", "Intrinsic", "::", "amdgcn_is_private", ":", "{", "unsigned", "TrueAS", "=", "IntrID", "==", "Intrinsic", "::", "amdgcn_is_shared", "?", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "unsigned", "NewAS", "=", "NewV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "NewV", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "ConstantInt", "*", "NewVal", "=", "(", "TrueAS", "==", "NewAS", ")", "?", "ConstantInt", "::", "getTrue", "(", "Ctx", ")", ":", "ConstantInt", "::", "getFalse", "(", "Ctx", ")", ";", "return", "NewVal", ";", "}", "case", "Intrinsic", "::", "ptrmask", ":", "{", "unsigned", "OldAS", "=", "OldV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "NewAS", "=", "NewV", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "Value", "*", "MaskOp", "=", "II", "->", "getArgOperand", "(", "1", ")", ";", "Type", "*", "MaskTy", "=", "MaskOp", "->", "getType", "(", ")", ";", "bool", "DoTruncate", "=", "false", ";", "if", "(", "!", "getTLI", "(", ")", "->", "isNoopAddrSpaceCast", "(", "OldAS", ",", "NewAS", ")", ")", "{", "if", "(", "DL", ".", "getPointerSizeInBits", "(", "OldAS", ")", "!=", "64", "||", "DL", ".", "getPointerSizeInBits", "(", "NewAS", ")", "!=", "32", ")", "return", "nullptr", ";", "KnownBits", "Known", "=", "computeKnownBits", "(", "MaskOp", ",", "DL", ",", "0", ",", "nullptr", ",", "II", ")", ";", "if", "(", "Known", ".", "countMinLeadingOnes", "(", ")", "<", "32", ")", "return", "nullptr", ";", "DoTruncate", "=", "true", ";", "}", "IRBuilder", "<", ">", "B", "(", "II", ")", ";", "if", "(", "DoTruncate", ")", "{", "MaskTy", "=", "B", ".", "getInt32Ty", "(", ")", ";", "MaskOp", "=", "B", ".", "CreateTrunc", "(", "MaskOp", ",", "MaskTy", ")", ";", "}", "return", "B", ".", "CreateIntrinsic", "(", "Intrinsic", "::", "ptrmask", ",", "{", "NewV", "->", "getType", "(", ")", ",", "MaskTy", "}", ",", "{", "NewV", ",", "MaskOp", "}", ")", ";", "}", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

[ "Rewrite", "intrinsic", "call", "II", "such", "that", "OldV", "will", "be", "replaced", "with", "NewV", ",", "which", "has", "a", "different", "address", "space", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "4", "Intrinsic::getDeclaration", "0", "Intrinsic::amdgcn_is_shared", "Intrinsic::amdgcn_is_private", "Intrinsic::amdgcn_is_shared", "AMDGPU", "AMDGPU", "Intrinsic::ptrmask", "1", "64", "32", "0", "32", "Intrinsic::ptrmask" ]

[]

[ "<s>", "void", "VERegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "VEFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Register", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ".", "getFixed", "(", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "offsetToDisp", "(", "MI", ")", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "STQrii", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "Register", "SrcHiReg", "=", "getSubReg", "(", "SrcReg", ",", "VE", "::", "sub_even", ")", ";", "Register", "SrcLoReg", "=", "getSubReg", "(", "SrcReg", ",", "VE", "::", "sub_odd", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "VE", "::", "STrii", ")", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcLoReg", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "*", "StMI", ",", "dl", ",", "0", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "VE", "::", "STrii", ")", ")", ";", "MI", ".", "getOperand", "(", "3", ")", ".", "setReg", "(", "SrcHiReg", ")", ";", "Offset", "+=", "8", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDQrii", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "DestHiReg", "=", "getSubReg", "(", "DestReg", ",", "VE", "::", "sub_even", ")", ";", "Register", "DestLoReg", "=", "getSubReg", "(", "DestReg", ",", "VE", "::", "sub_odd", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "VE", "::", "LDrii", ")", ",", "DestLoReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "*", "StMI", ",", "dl", ",", "1", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "VE", "::", "LDrii", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestHiReg", ")", ";", "Offset", "+=", "8", ";", "}", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "\"Unexpected\"", "VE", "VE::STQrii", "3", "VE::sub_even", "VE::sub_odd", "VE::STrii", "0", "0", "0", "VE::STrii", "3", "8", "VE::LDQrii", "0", "VE::sub_even", "VE::sub_odd", "VE::LDrii", "0", "0", "1", "VE::LDrii", "0", "8" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "ARM" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mips Emit GP Restore\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Emit GP Restore\"" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "AssumeMisalignedLoadStores", "||", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TD", "=", "&", "Fn", ".", "getDataLayout", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MF", "=", "&", "Fn", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MFI", ":", "Fn", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "&", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "TriCoreFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore" ]

[]

[ "<s>", "bool", "rs6000_is_valid_shift_mask", "(", "rtx", "mask", ",", "rtx", "shift", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "int", "n", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "int", "sh", "=", "-", "1", ";", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ")", "{", "sh", "=", "INTVAL", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ";", "if", "(", "sh", "<", "0", "||", "sh", ">=", "n", ")", "return", "false", ";", "}", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "if", "(", "sh", "==", "0", ")", "code", "=", "ROTATE", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "ne", ">=", "sh", ")", "code", "=", "ASHIFT", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "nb", "<", "sh", ")", "{", "code", "=", "LSHIFTRT", ";", "sh", "=", "n", "-", "sh", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "==", "63", "||", "ne", "==", "0", "||", "ne", "==", "sh", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", ")", ";", "if", "(", "ne", ">", "nb", ")", "return", "false", ";", "if", "(", "sh", "<", "0", ")", "return", "false", ";", "if", "(", "code", "==", "ASHIFT", "&&", "ne", "<", "sh", ")", "return", "false", ";", "if", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", "&&", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "32", "-", "sh", ")", ")", "return", "true", ";", "if", "(", "code", "==", "LSHIFTRT", ")", "sh", "=", "64", "-", "sh", ";", "if", "(", "nb", "==", "63", "||", "ne", "==", "0", "||", "ne", "==", "sh", ")", "return", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "sh", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlw", "[", "i", "]", "nm", ",", "rld", "[", "i", "]", "cl", ",", "rld", "[", "i", "]", "cr", ",", "or", "rld", "[", "i", "]", "c", "instruction", ",", "to", "implement", "an", "AND", "with", "shift", "SHIFT", "(", "a", "ROTATE", ",", "ASHIFT", ",", "or", "LSHIFTRT", ")", "in", "mode", "MODE", "." ]

[ "powerpcspe", "1", "1", "1", "0", "0", "0", "0", "63", "0", "32", "32", "32", "0", "32", "32", "32", "32", "64", "63", "0" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "bool", "MipsRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "unsigned", "FP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "FP", ":", "Mips", "::", "FP_64", ";", "unsigned", "BP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "S7", ":", "Mips", "::", "S7_64", ";", "if", "(", "!", "Subtarget", ".", "hasStandardEncoding", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "canReserveReg", "(", "FP", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "MF", ".", "getRegInfo", "(", ")", ".", "canReserveReg", "(", "BP", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::FP", "Mips::FP_64", "Mips::S7", "Mips::S7_64" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Offset", "=", "FIOffset", "+", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "3", "3", "3", "3", "3" ]

[]

[ "<s>", "CCAssignFn", "*", "X86FastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "isTaillCall", ")", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CC_X86_64_GHC", ";", "else", "if", "(", "Subtarget", "->", "isTargetWin64", "(", ")", ")", "return", "CC_X86_Win64_C", ";", "else", "return", "CC_X86_64_C", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "return", "CC_X86_32_FastCall", ";", "else", "if", "(", "CC", "==", "CallingConv", "::", "X86_ThisCall", ")", "return", "CC_X86_32_ThisCall", ";", "else", "if", "(", "CC", "==", "CallingConv", "::", "Fast", ")", "return", "CC_X86_32_FastCC", ";", "else", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CC_X86_32_GHC", ";", "else", "return", "CC_X86_32_C", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "arm_get_vfp_saved_size", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "int", "count", ";", "int", "saved", ";", "saved", "=", "0", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "count", "=", "0", ";", "for", "(", "regno", "=", "FIRST_VFP_REGNUM", ";", "regno", "<", "LAST_VFP_REGNUM", ";", "regno", "+=", "2", ")", "{", "if", "(", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "||", "call_used_regs", "[", "regno", "]", ")", "&&", "(", "!", "df_regs_ever_live_p", "(", "regno", "+", "1", ")", "||", "call_used_regs", "[", "regno", "+", "1", "]", ")", ")", "{", "if", "(", "count", ">", "0", ")", "{", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "count", "++", ";", "saved", "+=", "count", "*", "8", ";", "}", "count", "=", "0", ";", "}", "else", "count", "++", ";", "}", "if", "(", "count", ">", "0", ")", "{", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "count", "++", ";", "saved", "+=", "count", "*", "8", ";", "}", "}", "return", "saved", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "required", "to", "save", "VFP", "registers", "." ]

[ "arm", "0", "0", "2", "1", "1", "0", "2", "8", "0", "0", "2", "8" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "DLXInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "unsigned", "SourceRegister", ",", "bool", "IsKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RegisterClass", ",", "const", "TargetRegisterInfo", "*", "RegisterInfo", ")", "const", "{", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]