Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "ECLair", "1" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isAligned", "=", "(", "RI", ".", "getStackAlignment", "(", ")", ">=", "16", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "A57ChainingConstraint", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "const", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "LiveIntervals", "&", "LIs", "=", "G", ".", "getMetadata", "(", ")", ".", "LIS", ";", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MF", ")", "{", "Chains", ".", "clear", "(", ")", ";", "for", "(", "const", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "toDel", ";", "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Killing chain \"", "<<", "PrintReg", "(", "r", ",", "TRI", ")", "<<", "\" at \"", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FMSUBSrrr", ":", "case", "AArch64", "::", "FMADDSrrr", ":", "case", "AArch64", "::", "FNMSUBSrrr", ":", "case", "AArch64", "::", "FNMADDSrrr", ":", "case", "AArch64", "::", "FMSUBDrrr", ":", "case", "AArch64", "::", "FMADDDrrr", ":", "case", "AArch64", "::", "FNMSUBDrrr", ":", "case", "AArch64", "::", "FNMADDDrrr", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ra", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "AArch64", "::", "FMLAv2f32", ":", "case", "AArch64", "::", "FMLSv2f32", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AArch64", "8", "\"Killing chain \"", "\" at \"", "AArch64::FMSUBSrrr", "AArch64::FMADDSrrr", "AArch64::FNMSUBSrrr", "AArch64::FNMADDSrrr", "AArch64::FMSUBDrrr", "AArch64::FMADDDrrr", "AArch64::FNMSUBDrrr", "AArch64::FNMADDDrrr", "0", "3", "AArch64::FMLAv2f32", "AArch64::FMLSv2f32", "0" ]

[]

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

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

[ "Alpha", "Alpha", "Alpha" ]

[]

[ "<s>", "void", "AMDGPUPromoteKernelArguments", "::", "enqueueUsers", "(", "Value", "*", "Ptr", ")", "{", "SmallVector", "<", "User", "*", ">", "PtrUsers", "(", "Ptr", "->", "users", "(", ")", ")", ";", "while", "(", "!", "PtrUsers", ".", "empty", "(", ")", ")", "{", "Instruction", "*", "U", "=", "dyn_cast", "<", "Instruction", ">", "(", "PtrUsers", ".", "pop_back_val", "(", ")", ")", ";", "if", "(", "!", "U", ")", "continue", ";", "switch", "(", "U", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "{", "LoadInst", "*", "LD", "=", "cast", "<", "LoadInst", ">", "(", "U", ")", ";", "if", "(", "LD", "->", "getPointerOperand", "(", ")", "->", "stripInBoundsOffsets", "(", ")", "==", "Ptr", "&&", "!", "AMDGPU", "::", "isClobberedInFunction", "(", "LD", ",", "MSSA", ",", "AA", ")", ")", "Ptrs", ".", "push_back", "(", "LD", ")", ";", "break", ";", "}", "case", "Instruction", "::", "GetElementPtr", ":", "case", "Instruction", "::", "AddrSpaceCast", ":", "case", "Instruction", "::", "BitCast", ":", "if", "(", "U", "->", "getOperand", "(", "0", ")", "->", "stripInBoundsOffsets", "(", ")", "==", "Ptr", ")", "PtrUsers", ".", "append", "(", "U", "->", "user_begin", "(", ")", ",", "U", "->", "user_end", "(", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Enqueue", "the", "users", "of", "this", "instruction", "in", "the", "visit", "worklist", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isClobberedInFunction", "0" ]

[]

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

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

[ "AAP" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 Collect Linker Optimization Hint (LOH)\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Collect Linker Optimization Hint (LOH)\"" ]

[]

[ "<s>", "inline", "set_of_reg", "rx_find_set_of_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ",", "F", "stepfunc", ",", "bool", "ignore_reg_reg_copies", "=", "false", ")", "{", "set_of_reg", "result", ";", "result", ".", "insn", "=", "insn", ";", "result", ".", "set_rtx", "=", "NULL_RTX", ";", "result", ".", "set_src", "=", "NULL_RTX", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "insn", "==", "NULL_RTX", ")", "return", "result", ";", "for", "(", "rtx_insn", "*", "i", "=", "stepfunc", "(", "insn", ")", ";", "i", "!=", "NULL_RTX", ";", "i", "=", "stepfunc", "(", "i", ")", ")", "{", "if", "(", "BARRIER_P", "(", "i", ")", ")", "break", ";", "if", "(", "!", "INSN_P", "(", "i", ")", "||", "DEBUG_INSN_P", "(", "i", ")", ")", "continue", ";", "if", "(", "reg_set_p", "(", "reg", ",", "i", ")", ")", "{", "if", "(", "CALL_P", "(", "i", ")", ")", "break", ";", "result", ".", "insn", "=", "i", ";", "result", ".", "set_rtx", "=", "set_of", "(", "reg", ",", "i", ")", ";", "if", "(", "result", ".", "set_rtx", "==", "NULL_RTX", "||", "GET_CODE", "(", "result", ".", "set_rtx", ")", "!=", "SET", ")", "break", ";", "result", ".", "set_src", "=", "XEXP", "(", "result", ".", "set_rtx", ",", "1", ")", ";", "if", "(", "ignore_reg_reg_copies", "&&", "REG_P", "(", "result", ".", "set_src", ")", ")", "{", "reg", "=", "result", ".", "set_src", ";", "continue", ";", "}", "if", "(", "ignore_reg_reg_copies", "&&", "SUBREG_P", "(", "result", ".", "set_src", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "result", ".", "set_src", ")", ")", ")", "{", "reg", "=", "SUBREG_REG", "(", "result", ".", "set_src", ")", ";", "continue", ";", "}", "break", ";", "}", "}", "if", "(", "result", ".", "set_src", "!=", "NULL", "&&", "result", ".", "set_rtx", "==", "NULL", ")", "result", ".", "set_src", "=", "NULL", ";", "return", "result", ";", "}", "</s>" ]

[ "FIXME", ":", "Copy-pasta", "from", "SH", ".", "Move", "to", "rtl.h", ".", "Given", "a", "reg", "rtx", "and", "a", "start", "insn", ",", "try", "to", "find", "the", "insn", "that", "sets", "the", "specified", "reg", "by", "using", "the", "specified", "insn", "stepping", "function", ",", "such", "as", "'prev_nonnote_nondebug_insn_bb", "'", ".", "When", "the", "insn", "is", "found", ",", "try", "to", "extract", "the", "rtx", "of", "the", "reg", "set", "." ]

[ "rx", "1" ]

[]

[ "<s>", "static", "unsigned", "getHashValue", "(", "const", "SlotWithTag", "&", "V", ")", "{", "return", "hash_combine", "(", "DenseMapInfo", "<", "int", ">", "::", "getHashValue", "(", "V", ".", "FI", ")", ",", "DenseMapInfo", "<", "int", ">", "::", "getHashValue", "(", "V", ".", "Tag", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "void", "override_options", "(", ")", "{", "int", "def_align", ";", "int", "i", ";", "def_align", "=", "1", ";", "m68k_align_loops", "=", "def_align", ";", "if", "(", "m68k_align_loops_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_loops_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-loops=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_loops", "=", "i", ";", "}", "m68k_align_jumps", "=", "def_align", ";", "if", "(", "m68k_align_jumps_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_jumps_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-jumps=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_jumps", "=", "i", ";", "}", "m68k_align_funcs", "=", "def_align", ";", "if", "(", "m68k_align_funcs_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_funcs_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-functions=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_funcs", "=", "i", ";", "}", "}", "</s>" ]

[ "Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "." ]

[ "m68k", "1", "1", "\"-malign-loops=%d is not between 1 and %d\"", "1", "\"-malign-jumps=%d is not between 1 and %d\"", "1", "\"-malign-functions=%d is not between 1 and %d\"" ]

[]

[ "<s>", "SDValue", "LanaiSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "!", "MFI", ".", "isMaxCallFrameSizeComputed", "(", ")", "||", "MFI", ".", "getMaxCallFrameSize", "(", ")", ">", "DefaultSafeSPDisplacement", ")", "return", "true", ";", "if", "(", "MF", ".", "hasLocalEscape", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreSched2", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createNEONMoveFixPass", "(", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createIfConverterPass", "(", ")", ")", ";", "}", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "PM", ".", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "bool", "shouldInsertFencesForAtomic", "(", "const", "Instruction", "*", "I", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Helper", "functions", "for", "atomic", "operations", "." ]

[ "VE" ]

[]

[ "<s>", "bool", "aarch64_member_type_forces_blk", "(", "const_tree", "field_or_array", ",", "machine_mode", "mode", ")", "{", "const_tree", "type", "=", "TREE_TYPE", "(", "field_or_array", ")", ";", "unsigned", "int", "num_zr", ",", "num_pr", ";", "if", "(", "aarch64_sve", "::", "builtin_type_p", "(", "type", ",", "&", "num_zr", ",", "&", "num_pr", ")", "&&", "num_pr", "!=", "0", ")", "{", "if", "(", "TREE_CODE", "(", "field_or_array", ")", "==", "ARRAY_TYPE", ")", "return", "!", "simple_cst_equal", "(", "TYPE_SIZE", "(", "field_or_array", ")", ",", "TYPE_SIZE", "(", "type", ")", ")", ";", "return", "mode", "==", "VOIDmode", ";", "}", "return", "default_member_type_forces_blk", "(", "field_or_array", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMBER_TYPE_FORCES_BLK", "." ]

[ "aarch64", "aarch64_sve::builtin_type_p", "0" ]

[]

[ "<s>", "virtual", "EVT", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

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

[ "NVPTX", "MVT::getVectorVT", "MVT::i1", "MVT::i1" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "unsigned", "SGPRLimit", "=", "getNumSGPRsAllowed", "(", "STI", ".", "getGeneration", "(", ")", ",", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VGPRLimit", "=", "getNumVGPRsAllowed", "(", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "NumSubRegs", "=", "std", "::", "max", "(", "(", "int", ")", "(", "*", "I", ")", "->", "getSize", "(", ")", "/", "4", ",", "1", ")", ";", "unsigned", "Limit", ";", "if", "(", "isSGPRClass", "(", "*", "I", ")", ")", "{", "Limit", "=", "SGPRLimit", "/", "NumSubRegs", ";", "}", "else", "{", "Limit", "=", "VGPRLimit", "/", "NumSubRegs", ";", "}", "const", "int", "*", "Sets", "=", "getRegClassPressureSets", "(", "*", "I", ")", ";", "assert", "(", "Sets", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "Sets", "[", "i", "]", "!=", "-", "1", ";", "++", "i", ")", "{", "if", "(", "Sets", "[", "i", "]", "==", "(", "int", ")", "Idx", ")", "return", "Limit", ";", "}", "}", "return", "256", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "R600", "SI", "4", "1", "0", "1", "256" ]

[]

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

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

[ "M680x0", "M680x0", "M680x0" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::SWI", "0" ]

[]

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

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

[ "Dcpu16", "\"DCPU16 Assembly Printer\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValVReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Teak" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "isLabel", "(", "AsmToken", "&", "Token", ")", "{", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "AsmToken", "const", "&", "Second", "=", "Lexer", ".", "getTok", "(", ")", ";", "AsmToken", "Third", "=", "Lexer", ".", "peekTok", "(", ")", ";", "StringRef", "String", "=", "Token", ".", "getString", "(", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "LCurly", ")", "||", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "RCurly", ")", ")", "return", "false", ";", "if", "(", "String", ".", "lower", "(", ")", "==", "\"vwhist256\"", "&&", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", "&&", "Third", ".", "getString", "(", ")", ".", "lower", "(", ")", "==", "\"sat\"", ")", "return", "false", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "Identifier", ")", ")", "return", "true", ";", "if", "(", "!", "matchRegister", "(", "String", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "assert", "(", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", ")", ";", "StringRef", "Raw", "(", "String", ".", "data", "(", ")", ",", "Third", ".", "getString", "(", ")", ".", "data", "(", ")", "-", "String", ".", "data", "(", ")", "+", "Third", ".", "getString", "(", ")", ".", "size", "(", ")", ")", ";", "std", "::", "string", "Collapsed", "=", "std", "::", "string", "(", "Raw", ")", ";", "llvm", "::", "erase_if", "(", "Collapsed", ",", "isSpace", ")", ";", "StringRef", "Whole", "=", "Collapsed", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "DotSplit", "=", "Whole", ".", "split", "(", "'.'", ")", ";", "if", "(", "!", "matchRegister", "(", "DotSplit", ".", "first", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "Hexagon", "Hexagon", "\"vwhist256\"", "\"sat\"" ]

[]

[ "<s>", "static", "int", "get_reservation_flags", "(", "enum", "attr_units", "units", ")", "{", "switch", "(", "units", ")", "{", "case", "UNITS_D", ":", "case", "UNITS_D_ADDR", ":", "return", "RESERVATION_FLAG_D", ";", "case", "UNITS_L", ":", "return", "RESERVATION_FLAG_L", ";", "case", "UNITS_S", ":", "return", "RESERVATION_FLAG_S", ";", "case", "UNITS_M", ":", "return", "RESERVATION_FLAG_M", ";", "case", "UNITS_LS", ":", "return", "RESERVATION_FLAG_LS", ";", "case", "UNITS_DL", ":", "return", "RESERVATION_FLAG_DL", ";", "case", "UNITS_DS", ":", "return", "RESERVATION_FLAG_DS", ";", "case", "UNITS_DLS", ":", "return", "RESERVATION_FLAG_DLS", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Translate", "UNITS", "into", "a", "bitmask", "of", "units", "we", "can", "reserve", "for", "this", "insn", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "static", "bool", "chain_already_loaded", "(", "rtx_insn", "*", "last", ")", "{", "for", "(", ";", "last", "!=", "NULL", ";", "last", "=", "PREV_INSN", "(", "last", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "last", ")", ")", "{", "rtx", "patt", "=", "PATTERN", "(", "last", ")", ";", "if", "(", "GET_CODE", "(", "patt", ")", "==", "SET", ")", "{", "rtx", "lhs", "=", "XEXP", "(", "patt", ",", "0", ")", ";", "if", "(", "REG_P", "(", "lhs", ")", "&&", "REGNO", "(", "lhs", ")", "==", "STATIC_CHAIN_REGNUM", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "iff", "the", "sequence", "ending", "in", "LAST", "sets", "the", "static", "chain", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "int", "double_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", "||", "!", "memory_operand", "(", "op", ",", "mode", ")", ")", "{", "if", "(", "reload_in_progress", "&&", "GET_CODE", "(", "op", ")", "==", "REG", "&&", "REGNO", "(", "op", ")", ">=", "FIRST_PSEUDO_REGISTER", "&&", "reg_renumber", "[", "REGNO", "(", "op", ")", "]", "<", "0", "&&", "reg_equiv_mem", "(", "REGNO", "(", "op", ")", ")", "!=", "0", "&&", "double_memory_operand", "(", "reg_equiv_mem", "(", "REGNO", "(", "op", ")", ")", ",", "mode", ")", ")", "return", "1", ";", "return", "0", ";", "}", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", ")", "return", "1", ";", "return", "memory_address_p", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "?", "SImode", ":", "SFmode", ")", ",", "plus_constant", "(", "Pmode", ",", "addr", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "for", "a", "memory", "address", "that", "can", "be", "used", "to", "load", "or", "store", "a", "doubleword", "." ]

[ "microblaze", "0", "0", "1", "0", "0", "1", "4" ]

[]

[ "<s>", "void", "PPCAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "{", "if", "(", "!", "isVerbose", "(", ")", "||", "!", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "return", ";", "SmallString", "<", "32", ">", "Str", ";", "raw_svector_ostream", "O", "(", "Str", ")", ";", "unsigned", "NOps", "=", "MI", "->", "getNumOperands", "(", ")", ";", "assert", "(", "NOps", "==", "4", ")", ";", "O", "<<", "'\\t'", "<<", "MAI", "->", "getCommentString", "(", ")", "<<", "\"DEBUG_VALUE: \"", ";", "DIVariable", "V", "(", "const_cast", "<", "MDNode", "*", ">", "(", "MI", "->", "getOperand", "(", "NOps", "-", "1", ")", ".", "getMetadata", "(", ")", ")", ")", ";", "O", "<<", "V", ".", "getName", "(", ")", ";", "O", "<<", "\" <- \"", ";", "assert", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", ";", "O", "<<", "'['", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "'+'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "O", "<<", "']'", ";", "O", "<<", "\"+\"", ";", "printOperand", "(", "MI", ",", "NOps", "-", "2", ",", "O", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "case", "PPC", "::", "MovePCtoLR", ":", "case", "PPC", "::", "MovePCtoLR8", ":", "{", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "TmpInst", ".", "setOpcode", "(", "PPC", "::", "BL_Darwin", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "return", ";", "}", "case", "PPC", "::", "LDtoc", ":", "{", "LowerPPCMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "TmpInst", ".", "setOpcode", "(", "PPC", "::", "LD", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "assert", "(", "MO", ".", "isGlobal", "(", ")", ")", ";", "MCSymbol", "*", "&", "TOCEntry", "=", "TOC", "[", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", "]", ";", "if", "(", "TOCEntry", "==", "0", ")", "TOCEntry", "=", "GetTempSymbol", "(", "\"C\"", ",", "TOCLabelID", "++", ")", ";", "const", "MCExpr", "*", "Exp", "=", "MCSymbolRefExpr", "::", "Create", "(", "TOCEntry", ",", "MCSymbolRefExpr", "::", "VK_PPC_TOC", ",", "OutContext", ")", ";", "TmpInst", ".", "getOperand", "(", "1", ")", "=", "MCOperand", "::", "CreateExpr", "(", "Exp", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "return", ";", "}", "case", "PPC", "::", "MFCRpseud", ":", "OutStreamer", ".", "AddComment", "(", "PPCInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ";", "TmpInst", ".", "setOpcode", "(", "PPC", "::", "MFCR", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "return", ";", "}", "LowerPPCMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "32", "4", "\"DEBUG_VALUE: \"", "1", "\" <- \"", "0", "1", "0", "1", "\"+\"", "2", "PPC::MovePCtoLR", "PPC::MovePCtoLR8", "PPC::BL_Darwin", "PPC::LDtoc", "PPC", "PPC::LD", "1", "0", "\"C\"", "PPC", "1", "PPC::MFCRpseud", "PPC", "1", "PPC::MFCR", "0", "PPC" ]

[]

[ "<s>", "void", "TL45InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TL45", "::", "ADD", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "TL45", "::", "r0", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45::ADD", "TL45::r0" ]

[]

[ "<s>", "SDValue", "PIC16TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "NumRet", "=", "Outs", ".", "size", "(", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "std", "::", "string", "FuncName", "=", "F", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "createESName", "(", "PAN", "::", "getFrameLabel", "(", "FuncName", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i8", ",", "MVT", "::", "Other", ")", ";", "SDValue", "ES", "=", "DAG", ".", "getTargetExternalSymbol", "(", "tmpName", ",", "MVT", "::", "i8", ")", ";", "SDValue", "BS", "=", "DAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i8", ")", ";", "SDValue", "RetVal", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumRet", ";", "++", "i", ")", "{", "RetVal", "=", "Outs", "[", "i", "]", ".", "Val", ";", "Chain", "=", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "PIC16Store", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetVal", ",", "ES", ",", "BS", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i8", ")", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PIC16", "PIC16", "ISD::OutputArg", "MVT::i8", "MVT::Other", "MVT::i8", "1", "MVT::i8", "0", "PIC16ISD::PIC16Store", "MVT::Other", "MVT::i8", "PIC16ISD::RET", "MVT::Other" ]

[]

[ "<s>", "virtual", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "llvm_unreachable", "(", "\"getInstrInfo not implemented\"", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"getInstrInfo not implemented\"" ]

[]

[ "<s>", "bool", "arm_sat_operator_match", "(", "rtx", "lo_bound", ",", "rtx", "hi_bound", ",", "int", "*", "mask", ",", "bool", "*", "signed_sat", ")", "{", "int", "log", "=", "exact_log2", "(", "INTVAL", "(", "hi_bound", ")", "+", "1", ")", ";", "if", "(", "log", "==", "-", "1", ")", "return", "false", ";", "if", "(", "INTVAL", "(", "lo_bound", ")", "==", "0", ")", "{", "if", "(", "mask", ")", "*", "mask", "=", "log", ";", "if", "(", "signed_sat", ")", "*", "signed_sat", "=", "false", ";", "return", "true", ";", "}", "if", "(", "INTVAL", "(", "lo_bound", ")", "==", "-", "INTVAL", "(", "hi_bound", ")", "-", "1", ")", "{", "if", "(", "mask", ")", "*", "mask", "=", "log", "+", "1", ";", "if", "(", "signed_sat", ")", "*", "signed_sat", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Match", "pair", "of", "min/max", "operators", "that", "can", "be", "implemented", "via", "usat/ssat", "." ]

[ "arm", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "AttributeSet", "Set", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "A", "=", "Set", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"ShaderType\"", ")", ";", "unsigned", "ShaderType", "=", "ShaderType", "::", "COMPUTE", ";", "if", "(", "A", ".", "isStringAttribute", "(", ")", ")", "{", "StringRef", "Str", "=", "A", ".", "getValueAsString", "(", ")", ";", "Str", ".", "getAsInteger", "(", "0", ",", "ShaderType", ")", ";", "}", "if", "(", "ShaderType", "!=", "ShaderType", "::", "COMPUTE", ")", "{", "visit", "(", "F", ")", ";", "}", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI", "\"ShaderType\"", "0" ]

[]

[ "<s>", "void", "X86AvoidSFBPass", "::", "buildCopy", "(", "MachineInstr", "*", "LoadInst", ",", "unsigned", "NLoadOpcode", ",", "int64_t", "LoadDisp", ",", "MachineInstr", "*", "StoreInst", ",", "unsigned", "NStoreOpcode", ",", "int64_t", "StoreDisp", ",", "unsigned", "Size", ",", "int64_t", "LMMOffset", ",", "int64_t", "SMMOffset", ")", "{", "MachineOperand", "&", "LoadBase", "=", "getBaseOperand", "(", "LoadInst", ")", ";", "MachineOperand", "&", "StoreBase", "=", "getBaseOperand", "(", "StoreInst", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "LoadInst", "->", "getParent", "(", ")", ";", "MachineMemOperand", "*", "LMMO", "=", "*", "LoadInst", "->", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "SMMO", "=", "*", "StoreInst", "->", "memoperands_begin", "(", ")", ";", "Register", "Reg1", "=", "MRI", "->", "createVirtualRegister", "(", "TII", "->", "getRegClass", "(", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "0", ",", "TRI", ",", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", ";", "MachineInstr", "*", "NewLoad", "=", "BuildMI", "(", "*", "MBB", ",", "LoadInst", ",", "LoadInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "Reg1", ")", ".", "add", "(", "LoadBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "LoadDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "LMMO", ",", "LMMOffset", ",", "Size", ")", ")", ";", "if", "(", "LoadBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewLoad", ")", ".", "setIsKill", "(", "false", ")", ";", "LLVM_DEBUG", "(", "NewLoad", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "auto", "PrevInstrIt", "=", "prev_nodbg", "(", "MachineBasicBlock", "::", "instr_iterator", "(", "StoreInst", ")", ",", "MBB", "->", "instr_begin", "(", ")", ")", ";", "if", "(", "PrevInstrIt", ".", "getNodePtr", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "MachineInstr", "*", "NewStore", "=", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "if", "(", "StoreBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewStore", ")", ".", "setIsKill", "(", "false", ")", ";", "MachineOperand", "&", "StoreSrcVReg", "=", "StoreInst", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ";", "assert", "(", "StoreSrcVReg", ".", "isReg", "(", ")", "&&", "\"Expected virtual register\"", ")", ";", "NewStore", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "setIsKill", "(", "StoreSrcVReg", ".", "isKill", "(", ")", ")", ";", "LLVM_DEBUG", "(", "NewStore", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "COPY", "Op", "." ]

[ "X86", "X86", "0", "1", "X86::NoRegister", "X86::NoRegister", "1", "X86::NoRegister", "X86::NoRegister", "X86::AddrNumOperands", "\"Expected virtual register\"", "X86::AddrNumOperands" ]

[]

[ "<s>", "static", "inline", "bool", "pdp11_saved_regno", "(", "unsigned", "regno", ")", "{", "return", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ";", "}", "</s>" ]

[ "A", "helper", "function", "to", "determine", "if", "REGNO", "should", "be", "saved", "in", "the", "current", "function", "'s", "stack", "frame", "." ]

[ "pdp11" ]

[]

[ "<s>", "static", "tree", "aarch64_preferred_else_value", "(", "unsigned", ",", "tree", ",", "unsigned", "int", "nops", ",", "tree", "*", "ops", ")", "{", "return", "nops", "==", "3", "?", "ops", "[", "2", "]", ":", "ops", "[", "0", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_ELSE_VALUE", ".", "For", "binary", "operations", ",", "prefer", "to", "use", "the", "first", "arithmetic", "operand", "as", "the", "else", "value", "if", "the", "else", "value", "does", "n't", "matter", ",", "since", "that", "exactly", "matches", "the", "SVE", "destructive", "merging", "form", ".", "For", "ternary", "operations", "we", "could", "either", "pick", "the", "first", "operand", "and", "use", "FMAD-like", "instructions", "or", "the", "last", "operand", "and", "use", "FMLA-like", "instructions", ";", "the", "latter", "seems", "more", "natural", "." ]

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

[]

[ "<s>", "bool", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MOSTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Bad opcode.\"", ")", ";", "case", "MOS", "::", "SelectImm", ":", "return", "emitSelectImm", "(", "MI", ",", "MBB", ")", ";", "case", "MOS", "::", "IncMB", ":", "case", "MOS", "::", "DecMB", ":", "return", "emitIncDecMB", "(", "MI", ",", "MBB", ")", ";", "}", "}", "</s>" ]

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

[ "MOS", "MOS", "\"Bad opcode.\"", "MOS::SelectImm", "MOS::IncMB", "MOS::DecMB" ]

[]

[ "<s>", "static", "bool", "mips_refers_to_kernel_reg_p", "(", "const_rtx", "x", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "*", "iter", ")", "&&", "KERNEL_REG_P", "(", "REGNO", "(", "*", "iter", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "kernel", "register", "." ]

[ "mips" ]

[]

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

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

[ "ARC", "ARC" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FP_TO_SINT", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::OR", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART" ]

[]

[ "<s>", "void", "ARMELFStreamer", "::", "reset", "(", ")", "{", "MCTargetStreamer", "&", "TS", "=", "*", "getTargetStreamer", "(", ")", ";", "ARMTargetStreamer", "&", "ATS", "=", "static_cast", "<", "ARMTargetStreamer", "&", ">", "(", "TS", ")", ";", "ATS", ".", "reset", "(", ")", ";", "MappingSymbolCounter", "=", "0", ";", "MCELFStreamer", "::", "reset", "(", ")", ";", "LastMappingSymbols", ".", "clear", "(", ")", ";", "LastEMSInfo", ".", "reset", "(", ")", ";", "getAssembler", "(", ")", ".", "setELFHeaderEFlags", "(", "ELF", "::", "EF_ARM_EABI_VER5", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

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

[]

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

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

[ "R600", "\"AMDGPU Assembly Printer\"" ]

[]

[ "<s>", "void", "SparcFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "NumBytes", "+=", "92", ";", "NumBytes", "=", "(", "NumBytes", "+", "7", ")", "&", "~", "7", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "-", "4096", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVEri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "NumBytes", ">>", "10U", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ORri", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addImm", "(", "NumBytes", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SAVErr", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "92", "7", "7", "4096", "SP::SAVEri", "SP::O6", "SP::O6", "10U", "SP::SETHIi", "SP::G1", "SP::ORri", "SP::G1", "SP::G1", "1", "10", "1", "SP::SAVErr", "SP::O6", "SP::O6", "SP::G1" ]

[]

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

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

[ "Nyuzi", "Nyuzi::NumTargetFixupKinds" ]

[]

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

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,\"", "\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "AMDGPU", "\"+fp64-fp16-denormals,\"", "\"-fp32-denormals,\"", "\"+enable-prt-strict-null,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "64", "AMDGPU" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"AnyReg unimplemented on 32-bit AIX.\"", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "CSR_64_AllRegs_VSRP_SaveList", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", "&&", "!", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "return", "CSR_64_AllRegs_AIX_Dflt_VSX_SaveList", ";", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", "&&", "!", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", "return", "CSR_64_AllRegs_AIX_Dflt_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "}", "return", "CSR_64_AllRegs_SaveList", ";", "}", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", "&&", "!", "Subtarget", ".", "isUsingPCRelativeCalls", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"Cold calling unimplemented on AIX.\"", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_VSRP_SaveList", ":", "CSR_SVR64_ColdCC_VSRP_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ";", "}", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "CSR_SVR32_ColdCC_VSRP_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR32_ColdCC_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR32_ColdCC_SPE_SaveList", ";", "return", "CSR_SVR32_ColdCC_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR464_R2_VSRP_SaveList", ":", "CSR_SVR464_VSRP_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "(", "!", "Subtarget", ".", "isAIXABI", "(", ")", "||", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", ")", ")", "{", "return", "SaveR2", "?", "CSR_PPC64_R2_Altivec_SaveList", ":", "CSR_PPC64_Altivec_SaveList", ";", "}", "return", "SaveR2", "?", "CSR_PPC64_R2_SaveList", ":", "CSR_PPC64_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "TM", ".", "getAIXExtendedAltivecABI", "(", ")", "?", "CSR_AIX32_Altivec_SaveList", ":", "CSR_AIX32_SaveList", ";", "return", "CSR_AIX32_SaveList", ";", "}", "if", "(", "Subtarget", ".", "pairedVectorMemops", "(", ")", ")", "return", "CSR_SVR432_VSRP_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR432_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR432_SPE_SaveList", ";", "return", "CSR_SVR432_SaveList", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"AnyReg unimplemented on 32-bit AIX.\"", "PPC::X2", "\"Cold calling unimplemented on AIX.\"", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "VideocoreInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "int", "opc", ";", "if", "(", "VC", "::", "LowRegRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "VC", "::", "LowRegRegClass", ".", "contains", "(", "DestReg", ")", ")", "opc", "=", "VC", "::", "MOVqq", ";", "else", "opc", "=", "VC", "::", "MOVrr", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "VC::LowRegRegClass", "VC::LowRegRegClass", "VC::MOVqq", "VC::MOVrr" ]

[]

[ "<s>", "int", "mcore_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "ROUND_ADVANCE", "(", "size", ")", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "word", "sized", "registers", "needed", "to", "hold", "a", "function", "argument", "of", "mode", "MODE", "and", "type", "TYPE", "." ]

[ "mcore", "0" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "StackPtr", "=", "RegInfo", ".", "getStackRegister", "(", ")", ";", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "int", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "bool", "IsLP64", "=", "STI", ".", "isTarget64BitLP64", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "STI", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "Amount", ")", "{", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "IsLP64", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "Opc", "=", "getADDriOpcode", "(", "IsLP64", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", "&&", "InternalAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "IsLP64", ",", "InternalAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "InternalAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "0", "0", "1", "0", "0", "1", "3", "3" ]

[]

[ "<s>", "int", "mips_trampoline_code_size", "(", "void", ")", "{", "if", "(", "TARGET_USE_PIC_FN_ADDR_REG", ")", "return", "4", "*", "4", ";", "else", "if", "(", "ptr_mode", "==", "DImode", ")", "return", "8", "*", "4", ";", "else", "if", "(", "ISA_HAS_LOAD_DELAY", ")", "return", "6", "*", "4", ";", "else", "return", "4", "*", "4", ";", "}", "</s>" ]

[ "Return", "the", "size", "in", "bytes", "of", "the", "trampoline", "code", ",", "padded", "to", "TRAMPOLINE_ALIGNMENT", "bits", ".", "The", "static", "chain", "pointer", "and", "target", "function", "address", "immediately", "follow", "." ]

[ "mips", "4", "4", "8", "4", "6", "4", "4", "4" ]

[]

[ "<s>", "int", "ix86_secondary_memory_needed", "(", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ",", "enum", "machine_mode", "mode", ",", "int", "strict", ")", "{", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class1", ")", "||", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class1", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class2", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class1", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class2", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "{", "gcc_assert", "(", "!", "strict", ")", ";", "return", "true", ";", "}", "if", "(", "FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "TARGET_SSE2", ")", "return", "true", ";", "if", "(", "!", "TARGET_INTER_UNIT_MOVES", "&&", "!", "optimize_size", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "virtual", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "{", "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", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "OpKind", "::", "Token", ":", "OS", "<<", "\"Tok: \"", "<<", "Token", ".", "Data", ";", "break", ";", "case", "OpKind", "::", "Reg", ":", "OS", "<<", "\"Reg: \"", "<<", "TPCInstPrinter", "::", "getRegisterName", "(", "Reg", ".", "Num", ")", ";", "break", ";", "case", "OpKind", "::", "Imm", ":", "if", "(", "Imm", ".", "Expr", ")", "OS", "<<", "\"ImmExpr: \"", "<<", "Imm", ".", "Expr", ";", "else", "OS", "<<", "\"Imm: \"", "<<", "Imm", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "MemRI", ":", "OS", "<<", "\"Offset: \"", "<<", "MemRI", ".", "Offset", "<<", "\", Reg: \"", "<<", "TPCInstPrinter", "::", "getRegisterName", "(", "MemRI", ".", "Reg", ")", ";", "break", ";", "case", "OpKind", "::", "DataType", ":", "{", "static", "const", "StringRef", "OpTypes", "[", "]", "=", "{", "\"f32\"", ",", "\"bf16\"", ",", "\"i32\"", ",", "\"u32\"", ",", "\"i8\"", ",", "\"u8\"", ",", "\"b\"", ",", "\"i16\"", ",", "\"u16\"", ",", "\"f16\"", "}", ";", "assert", "(", "DataType", "<=", "TPCII", "::", "OpType", "::", "Max", ")", ";", "OS", "<<", "\"DataType: \"", "<<", "OpTypes", "[", "DataType", "]", ";", "break", ";", "}", "case", "OpKind", "::", "DimMask", ":", "assert", "(", "DimMask", "<", "32", ")", ";", "OS", "<<", "\"DimMask: \"", "<<", "std", "::", "bitset", "<", "5", ">", "(", "DimMask", ")", ".", "to_string", "(", ")", ";", "break", ";", "case", "OpKind", "::", "SwitchSet", ":", "OS", "<<", "\"SwitchSet: \"", "<<", "SwitchSet", ";", "break", ";", "case", "OpKind", "::", "Comparison", ":", "OS", "<<", "LoopCompareText", "[", "static_cast", "<", "unsigned", ">", "(", "CompInfo", ")", "]", ";", "break", ";", "case", "OpKind", "::", "Accumulator", ":", "OS", "<<", "\"Acc \"", ";", "break", ";", "case", "OpKind", "::", "SwitchLutPtr", ":", "OS", "<<", "\"SwitchSet with LutPtr: \"", "<<", "SwitchSet", ";", "break", ";", "case", "OpKind", "::", "SwitchAll", ":", "OS", "<<", "\"SwitchSet with All: \"", "<<", "SwitchSet", ";", "break", ";", "case", "OpKind", "::", "Predicate", ":", "OS", "<<", "\"Pred: \"", ";", "if", "(", "Pred", ".", "Polarity", ")", "OS", "<<", "\"!\"", ";", "OS", "<<", "TPCInstPrinter", "::", "getRegisterName", "(", "Pred", ".", "RegNum", ")", ";", "break", ";", "case", "OpKind", "::", "GroupDesc", ":", "OS", "<<", "\"GroupDesc: \"", "<<", "GroupDesc", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "RoundMode", ":", "OS", "<<", "\"RoundMode: \"", "<<", "RoundMode", ".", "Name", ";", "break", ";", "case", "OpKind", "::", "Rhu", ":", "OS", "<<", "\"RHU: \"", "<<", "Rhu", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "RhazRs", ":", "OS", "<<", "\"RHAZ_RS: \"", "<<", "RhazRs", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "DualGroup", ":", "case", "OpKind", "::", "WR", ":", "case", "OpKind", "::", "SDG", ":", "case", "OpKind", "::", "WEG", ":", "OS", "<<", "MovDualGroup", ".", "Name", "<<", "\"=\"", "<<", "MovDualGroup", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "RegSelFrom", ":", "OS", "<<", "\"RegSelFrom: \"", "<<", "RegSelFrom", ".", "Name", ";", "break", ";", "case", "OpKind", "::", "RegSelTo", ":", "OS", "<<", "\"RegSelTo: \"", "<<", "RegSelTo", ".", "Name", ";", "break", ";", "case", "OpKind", "::", "BothDivMod", ":", "OS", "<<", "\"BothDivMod: \"", "<<", "BothDivMod", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "X2", ":", "OS", "<<", "\"X2: \"", "<<", "X2", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "MovDGAll", ":", "OS", "<<", "\"MovDGAll: \"", "<<", "MovDGAll", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "MovDGPack", ":", "OS", "<<", "\"MovDGPack: \"", "<<", "MovDGPack", ".", "Val", ";", "break", ";", "case", "OpKind", "::", "MovDGUnpack", ":", "OS", "<<", "\"MovDGUnpack: \"", "<<", "MovDGUnpack", ".", "Val", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid operand kind\"", ")", ";", "}", "}", "</s>" ]

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

[ "TPC", "\"Tok: \"", "\"Reg: \"", "TPC", "\"ImmExpr: \"", "\"Imm: \"", "\"Offset: \"", "\", Reg: \"", "TPC", "\"f32\"", "\"bf16\"", "\"i32\"", "\"u32\"", "\"i8\"", "\"u8\"", "\"b\"", "\"i16\"", "\"u16\"", "\"f16\"", "TPC", "\"DataType: \"", "32", "\"DimMask: \"", "5", "\"SwitchSet: \"", "\"Acc \"", "\"SwitchSet with LutPtr: \"", "\"SwitchSet with All: \"", "\"Pred: \"", "\"!\"", "TPC", "\"GroupDesc: \"", "\"RoundMode: \"", "\"RHU: \"", "\"RHAZ_RS: \"", "\"=\"", "\"RegSelFrom: \"", "\"RegSelTo: \"", "\"BothDivMod: \"", "\"X2: \"", "\"MovDGAll: \"", "\"MovDGPack: \"", "\"MovDGUnpack: \"", "\"Invalid operand kind\"" ]

[]

[ "<s>", "SDValue", "SICTargetLowering", "::", "getTargetNode", "(", "JumpTableSDNode", "*", "N", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flag", ")", "const", "{", "return", "DAG", ".", "getTargetJumpTable", "(", "N", "->", "getIndex", "(", ")", ",", "Ty", ",", "Flag", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "int", "mcore_is_dead", "(", "rtx_insn", "*", "first", ",", "rtx", "reg", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "dead_or_set_p", "(", "first", ",", "reg", ")", ")", "return", "1", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "first", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", ")", "return", "0", ";", "else", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "if", "(", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", "||", "find_reg_fusage", "(", "insn", ",", "USE", ",", "reg", ")", ")", "return", "0", ";", "else", "if", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", ")", "return", "1", ";", "}", "else", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "0", ";", "else", "if", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Check", "whether", "reg", "is", "dead", "at", "first", ".", "This", "is", "done", "by", "searching", "ahead", "for", "either", "the", "next", "use", "(", "i.e.", ",", "reg", "is", "live", ")", ",", "a", "death", "note", ",", "or", "a", "set", "of", "reg", ".", "Do", "n't", "just", "use", "dead_or_set_p", "(", ")", "since", "reload", "does", "not", "always", "mark", "deaths", "(", "especially", "if", "PRESERVE_DEATH_NOTES_REGNO_P", "is", "not", "defined", ")", ".", "We", "can", "ignore", "subregs", "by", "extracting", "the", "actual", "register", ".", "BRC" ]

[ "mcore", "1", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "SUnit", "*", "SystemZPostRASchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "IsTopNode", "=", "true", ";", "if", "(", "Available", ".", "empty", "(", ")", ")", "return", "nullptr", ";", "if", "(", "Available", ".", "size", "(", ")", "==", "1", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Only one: \"", ";", "HazardRec", ".", "dumpSU", "(", "*", "Available", ".", "begin", "(", ")", ",", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "return", "*", "Available", ".", "begin", "(", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Available: \"", ";", "Available", ".", "dump", "(", "HazardRec", ")", ";", ")", ";", "Candidate", "Best", ";", "for", "(", "auto", "*", "SU", ":", "Available", ")", "{", "Candidate", "c", "(", "SU", ",", "HazardRec", ")", ";", "if", "(", "Best", ".", "SU", "==", "nullptr", "||", "c", "<", "Best", ")", "{", "Best", "=", "c", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Best sofar: \"", ";", "HazardRec", ".", "dumpSU", "(", "Best", ".", "SU", ",", "dbgs", "(", ")", ")", ";", "if", "(", "Best", ".", "GroupingCost", "!=", "0", ")", "dbgs", "(", ")", "<<", "\"\\tGrouping cost:\"", "<<", "Best", ".", "GroupingCost", ";", "if", "(", "Best", ".", "ResourcesCost", "!=", "0", ")", "dbgs", "(", ")", "<<", "\" Resource cost:\"", "<<", "Best", ".", "ResourcesCost", ";", "dbgs", "(", ")", "<<", "\" Height:\"", "<<", "Best", ".", "SU", "->", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "}", "if", "(", "!", "SU", "->", "isScheduleHigh", "&&", "Best", ".", "noCost", "(", ")", ")", "break", ";", "}", "assert", "(", "Best", ".", "SU", "!=", "nullptr", ")", ";", "return", "Best", ".", "SU", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "\"+++ Only one: \"", "\"\\n\"", "\"+++ Available: \"", "\"+++ Best sofar: \"", "0", "\"\\tGrouping cost:\"", "0", "\" Resource cost:\"", "\" Height:\"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "mips_function_rodata_section", "(", "tree", "decl", ")", "{", "if", "(", "!", "TARGET_ABICALLS", "||", "TARGET_GPWORD", ")", "default_function_rodata_section", "(", "decl", ")", ";", "else", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "const", "char", "*", "name", "=", "TREE_STRING_POINTER", "(", "DECL_SECTION_NAME", "(", "decl", ")", ")", ";", "if", "(", "DECL_ONE_ONLY", "(", "decl", ")", "&&", "strncmp", "(", "name", ",", "\".gnu.linkonce.t.\"", ",", "16", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "rname", "[", "14", "]", "=", "'d'", ";", "named_section_real", "(", "rname", ",", "SECTION_LINKONCE", "|", "SECTION_WRITE", ",", "decl", ")", ";", "}", "else", "if", "(", "flag_function_sections", "&&", "flag_data_sections", "&&", "strncmp", "(", "name", ",", "\".text.\"", ",", "6", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "memcpy", "(", "rname", "+", "1", ",", "\"data\"", ",", "4", ")", ";", "named_section_flags", "(", "rname", ",", "SECTION_WRITE", ")", ";", "}", "else", "data_section", "(", ")", ";", "}", "else", "data_section", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FUNCTION_RODATA_SECTION", ".", "The", "complication", "here", "is", "that", ",", "with", "the", "combination", "TARGET_ABICALLS", "&", "&", "!", "TARGET_GPWORD", ",", "jump", "tables", "will", "use", "absolute", "addresses", ",", "and", "should", "therefore", "not", "be", "included", "in", "the", "read-only", "part", "of", "a", "DSO", ".", "Handle", "such", "cases", "by", "selecting", "a", "normal", "data", "section", "instead", "of", "a", "read-only", "one", ".", "The", "logic", "apes", "that", "in", "default_function_rodata_section", "." ]

[ "mips", "\".gnu.linkonce.t.\"", "16", "0", "14", "\".text.\"", "6", "0", "1", "\"data\"", "4" ]

[]

[ "<s>", "llvm", "::", "Optional", "<", "unsigned", ">", "X86TTIImpl", "::", "getCacheSize", "(", "TargetTransformInfo", "::", "CacheLevel", "Level", ")", "const", "{", "switch", "(", "Level", ")", "{", "case", "TargetTransformInfo", "::", "CacheLevel", "::", "L1D", ":", "return", "32", "*", "1024", ";", "case", "TargetTransformInfo", "::", "CacheLevel", "::", "L2D", ":", "return", "256", "*", "1024", ";", "}", "llvm_unreachable", "(", "\"Unknown TargetTransformInfo::CacheLevel\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "cache", "size", "in", "bytes", "for", "the", "given", "level", "of", "cache", "." ]

[ "X86", "X86", "32", "1024", "256", "1024", "\"Unknown TargetTransformInfo::CacheLevel\"" ]

[]

[ "<s>", "static", "void", "riscv_set_current_function", "(", "tree", "decl", ")", "{", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", ")", "return", ";", "cfun", "->", "machine", "->", "naked_p", "=", "riscv_naked_function_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Sanity", "cheching", "for", "above", "function", "attributes", "." ]

[ "riscv" ]

[]

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

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

[ "TPC" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "isHardwareLoopProfitable", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "AssumptionCache", "&", "AC", ",", "TargetLibraryInfo", "*", "LibInfo", ",", "HardwareLoopInfo", "&", "HWLoopInfo", ")", "{", "const", "PPCTargetMachine", "&", "TM", "=", "ST", "->", "getTargetMachine", "(", ")", ";", "TargetSchedModel", "SchedModel", ";", "SchedModel", ".", "init", "(", "ST", ")", ";", "unsigned", "ConstTripCount", "=", "SE", ".", "getSmallConstantTripCount", "(", "L", ")", ";", "if", "(", "ConstTripCount", "&&", "ConstTripCount", "<", "SmallCTRLoopThreshold", ")", "{", "SmallPtrSet", "<", "const", "Value", "*", ",", "32", ">", "EphValues", ";", "CodeMetrics", "::", "collectEphemeralValues", "(", "L", ",", "&", "AC", ",", "EphValues", ")", ";", "CodeMetrics", "Metrics", ";", "for", "(", "BasicBlock", "*", "BB", ":", "L", "->", "blocks", "(", ")", ")", "Metrics", ".", "analyzeBasicBlock", "(", "BB", ",", "*", "this", ",", "EphValues", ")", ";", "if", "(", "Metrics", ".", "NumInsts", "<=", "(", "6", "*", "SchedModel", ".", "getIssueWidth", "(", ")", ")", ")", "return", "false", ";", "}", "SmallPtrSet", "<", "const", "Value", "*", ",", "4", ">", "Visited", ";", "for", "(", "Loop", "::", "block_iterator", "I", "=", "L", "->", "block_begin", "(", ")", ",", "IE", "=", "L", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "mightUseCTR", "(", "*", "I", ",", "LibInfo", ",", "Visited", ")", ")", "return", "false", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "for", "(", "auto", "&", "BB", ":", "ExitingBlocks", ")", "{", "Instruction", "*", "TI", "=", "BB", "->", "getTerminator", "(", ")", ";", "if", "(", "!", "TI", ")", "continue", ";", "if", "(", "BranchInst", "*", "BI", "=", "dyn_cast", "<", "BranchInst", ">", "(", "TI", ")", ")", "{", "uint64_t", "TrueWeight", "=", "0", ",", "FalseWeight", "=", "0", ";", "if", "(", "!", "BI", "->", "isConditional", "(", ")", "||", "!", "BI", "->", "extractProfMetadata", "(", "TrueWeight", ",", "FalseWeight", ")", ")", "continue", ";", "bool", "TrueIsExit", "=", "!", "L", "->", "contains", "(", "BI", "->", "getSuccessor", "(", "0", ")", ")", ";", "if", "(", "(", "TrueIsExit", "&&", "FalseWeight", "<", "TrueWeight", ")", "||", "(", "!", "TrueIsExit", "&&", "FalseWeight", ">", "TrueWeight", ")", ")", "return", "false", ";", "}", "}", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitBlocks", ";", "L", "->", "getExitBlocks", "(", "ExitBlocks", ")", ";", "for", "(", "auto", "&", "BB", ":", "ExitBlocks", ")", "{", "for", "(", "auto", "&", "PHI", ":", "BB", "->", "phis", "(", ")", ")", "{", "for", "(", "int", "Idx", "=", "0", ",", "EndIdx", "=", "PHI", ".", "getNumIncomingValues", "(", ")", ";", "Idx", "<", "EndIdx", ";", "Idx", "++", ")", "{", "const", "BasicBlock", "*", "IncomingBB", "=", "PHI", ".", "getIncomingBlock", "(", "Idx", ")", ";", "const", "Value", "*", "IncomingValue", "=", "PHI", ".", "getIncomingValue", "(", "Idx", ")", ";", "if", "(", "L", "->", "contains", "(", "IncomingBB", ")", "&&", "memAddrUsesCTR", "(", "IncomingValue", ",", "TM", ",", "Visited", ")", ")", "return", "false", ";", "}", "}", "}", "LLVMContext", "&", "C", "=", "L", "->", "getHeader", "(", ")", "->", "getContext", "(", ")", ";", "HWLoopInfo", ".", "CountType", "=", "TM", ".", "isPPC64", "(", ")", "?", "Type", "::", "getInt64Ty", "(", "C", ")", ":", "Type", "::", "getInt32Ty", "(", "C", ")", ";", "HWLoopInfo", ".", "LoopDecrement", "=", "ConstantInt", "::", "get", "(", "HWLoopInfo", ".", "CountType", ",", "1", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Query", "the", "target", "whether", "it", "would", "be", "profitable", "to", "convert", "the", "given", "loop", "into", "a", "hardware", "loop", "." ]

[ "PowerPC", "PPC", "PPC", "32", "6", "4", "4", "0", "0", "0", "4", "0", "PPC", "1" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "unsigned", "Size", "=", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "?", "4", ":", "8", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "Size", "-", "i", "-", "1", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "Idx", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "IsLittleEndian", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", ">>", "8", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", ">>", "8", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", "&", "0xFF", ";", "}", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "4", "8", "0", "1", "8", "8", "8", "2", "0xFF", "3", "8", "2", "8", "3", "0xFF" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "LM32PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createLM32ISelDag", "(", "getLM32TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "LM32", "LM32", "LM32", "LM32" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Local Dynamic TLS Access Clean-up\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"Local Dynamic TLS Access Clean-up\"" ]

[]

[ "<s>", "static", "tree", "ix86_generate_version_dispatcher_body", "(", "void", "*", "node_p", ")", "{", "tree", "resolver_decl", ";", "basic_block", "empty_bb", ";", "tree", "default_ver_decl", ";", "struct", "cgraph_node", "*", "versn", ";", "struct", "cgraph_node", "*", "node", ";", "struct", "cgraph_function_version_info", "*", "node_version_info", "=", "NULL", ";", "struct", "cgraph_function_version_info", "*", "versn_info", "=", "NULL", ";", "node", "=", "(", "cgraph_node", "*", ")", "node_p", ";", "node_version_info", "=", "node", "->", "function_version", "(", ")", ";", "gcc_assert", "(", "node", "->", "dispatcher_function", "&&", "node_version_info", "!=", "NULL", ")", ";", "if", "(", "node_version_info", "->", "dispatcher_resolver", ")", "return", "node_version_info", "->", "dispatcher_resolver", ";", "default_ver_decl", "=", "node_version_info", "->", "next", "->", "this_node", "->", "decl", ";", "node", "->", "definition", "=", "false", ";", "resolver_decl", "=", "make_resolver_func", "(", "default_ver_decl", ",", "node", "->", "decl", ",", "&", "empty_bb", ")", ";", "node_version_info", "->", "dispatcher_resolver", "=", "resolver_decl", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "resolver_decl", ")", ")", ";", "auto_vec", "<", "tree", ",", "2", ">", "fn_ver_vec", ";", "for", "(", "versn_info", "=", "node_version_info", "->", "next", ";", "versn_info", ";", "versn_info", "=", "versn_info", "->", "next", ")", "{", "versn", "=", "versn_info", "->", "this_node", ";", "if", "(", "DECL_VINDEX", "(", "versn", "->", "decl", ")", ")", "sorry", "(", "\"Virtual function multiversioning not supported\"", ")", ";", "fn_ver_vec", ".", "safe_push", "(", "versn", "->", "decl", ")", ";", "}", "dispatch_function_versions", "(", "resolver_decl", ",", "&", "fn_ver_vec", ",", "&", "empty_bb", ")", ";", "cgraph_edge", "::", "rebuild_edges", "(", ")", ";", "pop_cfun", "(", ")", ";", "return", "resolver_decl", ";", "}", "</s>" ]

[ "Generate", "the", "dispatching", "code", "body", "to", "dispatch", "multi-versioned", "function", "DECL", ".", "The", "target", "hook", "is", "called", "to", "process", "the", "``", "target", "''", "attributes", "and", "provide", "the", "code", "to", "dispatch", "the", "right", "function", "at", "run-time", ".", "NODE", "points", "to", "the", "dispatcher", "decl", "whose", "body", "will", "be", "created", "." ]

[ "i386", "2", "\"Virtual function multiversioning not supported\"" ]

[]

[ "<s>", "bool", "nds32_n8_load_to_ii_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "if", "(", "post_update_insn_p", "(", "producer", ")", ")", "return", "false", ";", "rtx", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "return", "n8_consumed_by_addr_in_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Guard", "functions", "for", "N8", "core", "." ]

[ "nds32" ]

[]

[ "<s>", "static", "const", "FunctionType", "*", "getType", "(", "LLVMContext", "&", "Context", ",", "unsigned", "id", ")", "{", "const", "Type", "*", "ResultTy", "=", "NULL", ";", "std", "::", "vector", "<", "const", "Type", "*", ">", "ArgTys", ";", "bool", "IsVarArg", "=", "false", ";", "return", "FunctionType", "::", "get", "(", "ResultTy", ",", "ArgTys", ",", "IsVarArg", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "MBlaze" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "return", "5", "-", "HasFP", ";", "}", "case", "ARM", "::", "GPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "return", "10", "-", "HasFP", "-", "STI", ".", "getNumGPRegistersReserved", "(", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "32", "-", "10", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "0", "ARM::tGPRRegClassID", "5", "ARM::GPRRegClassID", "10", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "32", "10" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "1", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"code size not handled\"", "0", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "AArch64", "::", "WZR", ":", "AArch64", "::", "XZR", ";", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "case", "'z'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "AArch64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "AArch64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "AArch64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "break", ";", "case", "'z'", ":", "RC", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "AArch64", "::", "NoRegAltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "AArch64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "if", "(", "AArch64", "::", "GPR64x8ClassRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'t'", ",", "O", ")", ";", "unsigned", "AltName", "=", "AArch64", "::", "NoRegAltName", ";", "const", "TargetRegisterClass", "*", "RegClass", ";", "if", "(", "AArch64", "::", "ZPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "RegClass", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "}", "else", "if", "(", "AArch64", "::", "PPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "RegClass", "=", "&", "AArch64", "::", "PPRRegClass", ";", "}", "else", "{", "RegClass", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "AltName", "=", "AArch64", "::", "vreg", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RegClass", ",", "AltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AArch64", "AArch64", "0", "1", "0", "0", "0", "0", "0", "AArch64::WZR", "AArch64::XZR", "AArch64", "0", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ZPRRegClass", "AArch64::NoRegAltName", "AArch64::GPR32allRegClass", "AArch64::GPR64allRegClass", "AArch64::GPR64x8ClassRegClass", "AArch64::NoRegAltName", "AArch64::ZPRRegClass", "AArch64::ZPRRegClass", "AArch64::PPRRegClass", "AArch64::PPRRegClass", "AArch64::FPR128RegClass", "AArch64::vreg" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "while", "(", "Result", "==", "Success", "&&", "Complete", "==", "false", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon::BUNDLE", "0" ]

[]

[ "<s>", "unsigned", "MCS51InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"MCS51 branch conditions have one component!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "MCS51", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "MCS51CC", "::", "CondCodes", "CC", "=", "(", "MCS51CC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "auto", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "MCS51", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "MCS51", "MCS51", "0", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"MCS51 branch conditions have one component!\"", "\"Unconditional branch with multiple successors!\"", "MCS51::RJMPk", "1", "0", "MCS51CC::CondCodes", "MCS51CC::CondCodes", "0", "MCS51::RJMPk" ]

[]

[ "<s>", "virtual", "const", "IA64RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "IA64", "IA64" ]

[]

[ "<s>", "SDNode", "*", "PTXDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "PTXISD", "::", "READ_PARAM", ")", "return", "SelectREAD_PARAM", "(", "Node", ")", ";", "else", "return", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "PTX", "PTX", "PTXISD::READ_PARAM" ]

[]

[ "<s>", "static", "int", "loongarch_fp_div_cost", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "DFmode", "?", "loongarch_cost", "->", "fp_div_df", ":", "loongarch_cost", "->", "fp_div_sf", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "floating-point", "divisions", "of", "mode", "MODE", "." ]

[ "loongarch" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "PBQPRAConstraint", ">", "AArch64Subtarget", "::", "getCustomPBQPConstraints", "(", ")", "const", "{", "if", "(", "!", "isCortexA57", "(", ")", ")", "return", "nullptr", ";", "return", "llvm", "::", "make_unique", "<", "A57ChainingConstraint", ">", "(", ")", ";", "}", "</s>" ]

[ "Return", "PBQPConstraint", "(", "s", ")", "for", "the", "target", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "rs6000_emit_allocate_stack", "(", "HOST_WIDE_INT", "size", ",", "int", "copy_r12", ")", "{", "rtx", "insn", ";", "rtx", "stack_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx", "todec", "=", "gen_int_mode", "(", "-", "size", ",", "Pmode", ")", ";", "if", "(", "INTVAL", "(", "todec", ")", "!=", "-", "size", ")", "{", "warning", "(", "0", ",", "\"stack frame too large\"", ")", ";", "emit_insn", "(", "gen_trap", "(", ")", ")", ";", "return", ";", "}", "if", "(", "current_function_limit_stack", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", "&&", "REGNO", "(", "stack_limit_rtx", ")", ">", "1", "&&", "REGNO", "(", "stack_limit_rtx", ")", "<=", "31", ")", "{", "emit_insn", "(", "TARGET_32BIT", "?", "gen_addsi3", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ":", "gen_adddi3", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "stack_limit_rtx", ")", "==", "SYMBOL_REF", "&&", "TARGET_32BIT", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "rtx", "toload", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_elf_high", "(", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_elf_low", "(", "tmp_reg", ",", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "warning", "(", "0", ",", "\"stack limit expression is not supported\"", ")", ";", "}", "if", "(", "copy_r12", "||", "!", "TARGET_UPDATE", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ",", "stack_reg", ")", ";", "if", "(", "TARGET_UPDATE", ")", "{", "if", "(", "size", ">", "32767", ")", "{", "if", "(", "get_last_insn", "(", ")", "==", "NULL_RTX", ")", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "insn", "=", "emit_move_insn", "(", "tmp_reg", ",", "todec", ")", ";", "try_split", "(", "PATTERN", "(", "insn", ")", ",", "insn", ",", "0", ")", ";", "todec", "=", "tmp_reg", ";", "}", "insn", "=", "emit_insn", "(", "TARGET_32BIT", "?", "gen_movsi_update", "(", "stack_reg", ",", "stack_reg", ",", "todec", ",", "stack_reg", ")", ":", "gen_movdi_di_update", "(", "stack_reg", ",", "stack_reg", ",", "todec", ",", "stack_reg", ")", ")", ";", "}", "else", "{", "insn", "=", "emit_insn", "(", "TARGET_32BIT", "?", "gen_addsi3", "(", "stack_reg", ",", "stack_reg", ",", "todec", ")", ":", "gen_adddi3", "(", "stack_reg", ",", "stack_reg", ",", "todec", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "stack_reg", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_reg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_reg", ",", "GEN_INT", "(", "-", "size", ")", ")", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "correct", "code", "for", "allocating", "stack", "space", ",", "as", "insns", ".", "If", "COPY_R12", ",", "make", "sure", "a", "copy", "of", "the", "old", "frame", "is", "left", "in", "r12", ".", "The", "generated", "code", "may", "use", "hard", "register", "0", "as", "a", "temporary", "." ]

[ "rs6000", "0", "0", "\"stack frame too large\"", "1", "31", "0", "\"stack limit expression is not supported\"", "12", "32767", "0", "12", "1" ]

[]

[ "<s>", "static", "rtx", "mips_function_value_1", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "machine_mode", "mode", ")", "{", "if", "(", "valtype", ")", "{", "tree", "fields", "[", "2", "]", ";", "int", "unsigned_p", ";", "const_tree", "func", ";", "if", "(", "fn_decl_or_type", "&&", "DECL_P", "(", "fn_decl_or_type", ")", ")", "func", "=", "fn_decl_or_type", ";", "else", "func", "=", "NULL", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "func", ",", "1", ")", ";", "bool", "has_cxx_zero_width_bf", "=", "false", ";", "bool", "has_cxx17_empty_base", "=", "false", ";", "int", "use_fpr", "=", "mips_fpr_return_fields", "(", "valtype", ",", "fields", ",", "&", "has_cxx_zero_width_bf", ",", "&", "has_cxx17_empty_base", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "warn_psabi", "&&", "has_cxx_zero_width_bf", "&&", "!", "has_cxx17_empty_base", "&&", "use_fpr", "!=", "0", ")", "{", "static", "unsigned", "last_reported_type_uid", ";", "unsigned", "uid", "=", "TYPE_UID", "(", "TYPE_MAIN_VARIANT", "(", "valtype", ")", ")", ";", "if", "(", "uid", "!=", "last_reported_type_uid", ")", "{", "static", "const", "char", "*", "url", "=", "CHANGES_ROOT_URL", "\"gcc-12/changes.html#zero_width_bitfields\"", ";", "inform", "(", "input_location", ",", "\"the ABI for returning a value containing \"", "\"zero-width bit-fields but otherwise an aggregate \"", "\"with only one or two floating-point fields was \"", "\"changed in GCC %{12.1%}\"", ",", "url", ")", ";", "last_reported_type_uid", "=", "uid", ";", "}", "}", "if", "(", "has_cxx_zero_width_bf", ")", "use_fpr", "=", "0", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "warn_psabi", "&&", "use_fpr", "!=", "0", "&&", "has_cxx17_empty_base", ")", "{", "static", "unsigned", "last_reported_type_uid", ";", "unsigned", "uid", "=", "TYPE_UID", "(", "TYPE_MAIN_VARIANT", "(", "valtype", ")", ")", ";", "if", "(", "uid", "!=", "last_reported_type_uid", ")", "{", "static", "const", "char", "*", "url", "=", "CHANGES_ROOT_URL", "\"gcc-12/changes.html#mips_cxx17_empty_bases\"", ";", "inform", "(", "input_location", ",", "\"the ABI for returning a value with C++17 empty \"", "\"bases but otherwise an aggregate with only one or \"", "\"two floating-point fields was changed in GCC \"", "\"%{12.1%}\"", ",", "url", ")", ";", "last_reported_type_uid", "=", "uid", ";", "}", "}", "switch", "(", "use_fpr", ")", "{", "case", "1", ":", "return", "mips_return_fpr_single", "(", "mode", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "0", "]", ")", ")", ")", ";", "case", "2", ":", "return", "mips_return_fpr_pair", "(", "mode", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "0", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "0", "]", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "1", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "1", "]", ")", ")", ";", "}", "if", "(", "mips_return_in_msb", "(", "valtype", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "require", "(", ")", ";", "}", "}", "if", "(", "mips_abi", "!=", "ABI_EABI", "&&", "!", "FLOAT_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "if", "(", "!", "TARGET_MIPS16", ")", "{", "if", "(", "mode", "==", "TFmode", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "DImode", ",", "0", ",", "DImode", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "if", "(", "mips_return_mode_in_fpr_p", "(", "mode", ")", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "0", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "FP_RETURN", ")", ";", "}", "}", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "and", "TARGET_LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

[ "mips", "2", "1", "0", "\"gcc-12/changes.html#zero_width_bitfields\"", "\"the ABI for returning a value containing \"", "\"zero-width bit-fields but otherwise an aggregate \"", "\"with only one or two floating-point fields was \"", "\"changed in GCC %{12.1%}\"", "0", "0", "\"gcc-12/changes.html#mips_cxx17_empty_bases\"", "\"the ABI for returning a value with C++17 empty \"", "\"bases but otherwise an aggregate with only one or \"", "\"two floating-point fields was changed in GCC \"", "\"%{12.1%}\"", "1", "0", "2", "0", "0", "1", "1", "0", "0", "0", "2", "0", "2" ]

[]

[ "<s>", "enum", "reg_class", "mips_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "mips_dangerous_for_la25_p", "(", "x", ")", "&&", "reg_class_subset_p", "(", "LEA_REGS", ",", "class", ")", ")", "return", "LEA_REGS", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "FLOAT_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", "&&", "reg_class_subset_p", "(", "FP_REGS", ",", "class", ")", ")", "return", "FP_REGS", ";", "if", "(", "reg_class_subset_p", "(", "GR_REGS", ",", "class", ")", ")", "class", "=", "GR_REGS", ";", "if", "(", "TARGET_MIPS16", "&&", "reg_class_subset_p", "(", "M16_REGS", ",", "class", ")", ")", "class", "=", "M16_REGS", ";", "return", "class", ";", "}", "</s>" ]

[ "Implement", "PREFERRED_RELOAD_CLASS", "." ]

[ "mips" ]

[]

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

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

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

[]

[ "<s>", "bool", "RISCVOptimizeVSETVLUses", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "Fn", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasStdExtV", "(", ")", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "Fn", ".", "getRegInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Optimizing VSETVL in \"", "<<", "Fn", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\" ***\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "for", "(", "MachineInstr", "&", "Instr", ":", "MBB", ")", "{", "if", "(", "Instr", ".", "isCopy", "(", ")", ")", "{", "const", "auto", "&", "CopyDest", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "auto", "&", "CopySource", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "const", "MachineInstr", "*", "MI", "=", "MRI", ".", "getVRegDef", "(", "CopySource", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MI", ")", "{", "continue", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "VSETVL", "&&", "!", "isSameRegisterClass", "(", "CopyDest", ".", "getReg", "(", ")", ",", "CopySource", ".", "getReg", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Found COPY instruction from VSETVL\"", "<<", "\"across register class\"", "<<", "\" ***\\n\"", ")", ";", "LLVM_DEBUG", "(", "Instr", ".", "dump", "(", ")", ")", ";", "const", "auto", "&", "VSETVLDefGPR", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "const", "auto", "&", "VSETVLDefVLR", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "const", "auto", "&", "Replacement", "=", "VSETVLDefGPR", ".", "getReg", "(", ")", "!=", "CopySource", ".", "getReg", "(", ")", "?", "VSETVLDefGPR", ":", "VSETVLDefVLR", ";", "CopySource", ".", "setIsKill", "(", "false", ")", ";", "CopySource", ".", "setReg", "(", "Replacement", ".", "getReg", "(", ")", ")", ";", "MRI", ".", "clearKillFlags", "(", "Replacement", ".", "getReg", "(", ")", ")", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"*** Optimizing VSETVL in \"", "\" ***\\n\"", "0", "1", "RISCV::VSETVL", "\"*** Found COPY instruction from VSETVL\"", "\"across register class\"", "\" ***\\n\"", "0", "1" ]

[]

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

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

[ "Hexagon", "\"Hexagon Store Widening\"" ]

[]

[ "<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "8", ";", "}", "</s>" ]

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "ARM64", "8" ]

[]

[ "<s>", "void", "aarch64_init_builtins", "(", "void", ")", "{", "tree", "ftype_set_fpr", "=", "build_function_type_list", "(", "void_type_node", ",", "unsigned_type_node", ",", "NULL", ")", ";", "tree", "ftype_get_fpr", "=", "build_function_type_list", "(", "unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_get_fpcr\"", ",", "ftype_get_fpr", ",", "AARCH64_BUILTIN_GET_FPCR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_set_fpcr\"", ",", "ftype_set_fpr", ",", "AARCH64_BUILTIN_SET_FPCR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_get_fpsr\"", ",", "ftype_get_fpr", ",", "AARCH64_BUILTIN_GET_FPSR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_set_fpsr\"", ",", "ftype_set_fpr", ",", "AARCH64_BUILTIN_SET_FPSR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_fp16_type_node", "=", "make_node", "(", "REAL_TYPE", ")", ";", "TYPE_PRECISION", "(", "aarch64_fp16_type_node", ")", "=", "16", ";", "layout_type", "(", "aarch64_fp16_type_node", ")", ";", "(", "*", "lang_hooks", ".", "types", ".", "register_builtin_type", ")", "(", "aarch64_fp16_type_node", ",", "\"__fp16\"", ")", ";", "if", "(", "TARGET_SIMD", ")", "aarch64_init_simd_builtins", "(", ")", ";", "aarch64_init_crc32_builtins", "(", ")", ";", "aarch64_init_builtin_rsqrt", "(", ")", ";", "}", "</s>" ]

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

[ "aarch64", "\"__builtin_aarch64_get_fpcr\"", "\"__builtin_aarch64_set_fpcr\"", "\"__builtin_aarch64_get_fpsr\"", "\"__builtin_aarch64_set_fpsr\"", "16", "\"__fp16\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "EnableSVEIntrinsicOpts", "&&", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createSVEIntrinsicOptsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "true", ",", "true", ",", "false", ",", "true", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorMarkStridedAccessesPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAArch64StackTaggingPass", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedLoadCombinePass", "(", ")", ")", ";", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "void", "gen_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "mode", ")", "{", "enum", "rtx_code", "test_code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "cmp0", "=", "operands", "[", "1", "]", ";", "rtx", "cmp1", "=", "operands", "[", "2", "]", ";", "rtx", "reg", ";", "int", "invert", ";", "rtx", "label1", ",", "label2", ";", "invert", "=", "0", ";", "reg", "=", "gen_int_relational", "(", "test_code", ",", "NULL_RTX", ",", "cmp0", ",", "cmp1", ",", "&", "invert", ")", ";", "if", "(", "reg", ")", "{", "cmp0", "=", "reg", ";", "cmp1", "=", "const0_rtx", ";", "test_code", "=", "NE", ";", "}", "else", "if", "(", "GET_CODE", "(", "cmp1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "cmp1", ")", "!=", "0", ")", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "label1", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ";", "label2", "=", "pc_rtx", ";", "if", "(", "invert", ")", "{", "label2", "=", "label1", ";", "label1", "=", "pc_rtx", ";", "}", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "test_code", ",", "VOIDmode", ",", "cmp0", ",", "cmp1", ")", ",", "label1", ",", "label2", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "code", "for", "doing", "conditional", "branches", ".", "operand", "[", "0", "]", "is", "the", "label", "to", "jump", "to", ".", "The", "comparison", "operands", "are", "saved", "away", "by", "cmp", "{", "si", ",", "di", ",", "sf", ",", "df", "}", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lanai load / store optimization pass\"", ";", "}", "</s>" ]

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

[ "Lanai", "\"Lanai load / store optimization pass\"" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Shrink-wrapping not yet supported\"", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "bool", "vax_mode_dependent_address_p", "(", "const_rtx", "x", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "xfoo0", ",", "xfoo1", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "false", ";", "xfoo0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "xfoo1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "CONST_INT_P", "(", "xfoo0", ")", "&&", "REG_P", "(", "xfoo1", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "xfoo1", ")", "&&", "REG_P", "(", "xfoo0", ")", ")", "return", "false", ";", "if", "(", "!", "flag_pic", "&&", "CONSTANT_ADDRESS_P", "(", "xfoo0", ")", "&&", "REG_P", "(", "xfoo1", ")", ")", "return", "false", ";", "if", "(", "!", "flag_pic", "&&", "CONSTANT_ADDRESS_P", "(", "xfoo1", ")", "&&", "REG_P", "(", "xfoo0", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "1", "if", "x", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "On", "the", "VAX", ",", "the", "predecrement", "and", "postincrement", "address", "depend", "thus", "(", "the", "amount", "of", "decrement", "or", "increment", "being", "the", "length", "of", "the", "operand", ")", "and", "all", "indexed", "address", "depend", "thus", "(", "because", "the", "index", "scale", "factor", "is", "the", "length", "of", "the", "operand", ")", "." ]

[ "vax", "0", "1" ]

[]

[ "<s>", "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "orig_x", "=", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MULT", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "MULT", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "x", "!=", "orig_x", "&&", "legitimate_address_p", "(", "mode", ",", "x", ",", "FALSE", ")", ")", "return", "x", ";", "if", "(", "SPARC_SYMBOL_REF_TLS_P", "(", "x", ")", ")", "x", "=", "legitimize_tls_address", "(", "x", ")", ";", "else", "if", "(", "flag_pic", ")", "x", "=", "legitimize_pic_address", "(", "x", ",", "mode", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "x", "=", "copy_to_suggested_reg", "(", "x", ",", "NULL_RTX", ",", "Pmode", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "." ]

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SDValue", "Op", "(", "N", ",", "0", ")", ";", "if", "(", "isHvxOperation", "(", "Op", ")", ")", "{", "if", "(", "SDValue", "V", "=", "PerformHvxDAGCombine", "(", "N", ",", "DCI", ")", ")", "return", "V", ";", "return", "SDValue", "(", ")", ";", "}", "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>", "int", "c4x_Q_constraint", "(", "rtx", "op", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "return", "0", ";", "if", "(", "REG_P", "(", "op1", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", ")", "return", "0", ";", "if", "(", "mode", "==", "HImode", "||", "mode", "==", "HFmode", ")", "return", "IS_DISP8_OFF_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "return", "IS_DISP8_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "ARx", "+", "9-bit", "signed", "const", "or", "IRn", "*", "ARx", ",", "*", "+ARx", "(", "n", ")", ",", "*", "-ARx", "(", "n", ")", ",", "*", "+ARx", "(", "IRn", ")", ",", "*", "-Arx", "(", "IRn", ")", "for", "-256", "<", "n", "<", "256", "We", "do", "n't", "include", "the", "pre/post", "inc/dec", "forms", "here", "since", "they", "are", "handled", "by", "the", "<", ">", "constraints", "." ]

[ "c4x", "0", "0", "1", "0", "1", "0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getNumRegPressureSets", "(", ")", "const", "{", "return", "4", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "dimensions", "of", "register", "pressure", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Hexagon.\"", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Hexagon.\"", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::VASTART", "ISD::BR_JT", "ISD::DYNAMIC_STACKALLOC", "ISD::SELECT_CC", "ISD::INTRINSIC_WO_CHAIN", "ISD::INLINEASM" ]

[]