Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "riscv_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "args", ";", "cumulative_args_t", "cum", "=", "pack_cumulative_args", "(", "&", "args", ")", ";", "memset", "(", "&", "args", ",", "0", ",", "sizeof", "args", ")", ";", "function_arg_info", "arg", "(", "const_cast", "<", "tree", ">", "(", "type", ")", ",", "true", ")", ";", "return", "riscv_pass_by_reference", "(", "cum", ",", "arg", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", "." ]

[ "riscv", "0" ]

[]

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

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "static", "int", "ia64_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type1", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "dw_t", "dw", ")", "{", "enum", "reg_note", "dep_type", "=", "(", "enum", "reg_note", ")", "dep_type1", ";", "enum", "attr_itanium_class", "dep_class", ";", "enum", "attr_itanium_class", "insn_class", ";", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "dep_class", "=", "ia64_safe_itanium_class", "(", "dep_insn", ")", ";", "if", "(", "dep_type", "==", "REG_DEP_TRUE", "&&", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "&&", "(", "insn_class", "==", "ITANIUM_CLASS_BR", "||", "insn_class", "==", "ITANIUM_CLASS_SCALL", ")", ")", "return", "0", ";", "if", "(", "dw", "==", "MIN_DEP_WEAK", ")", "return", "param_sched_mem_true_dep_cost", ";", "else", "if", "(", "dw", ">", "MIN_DEP_WEAK", ")", "{", "if", "(", "mflag_sched_fp_mem_deps_zero_cost", "&&", "dep_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "else", "return", "cost", ";", "}", "if", "(", "dep_type", "!=", "REG_DEP_OUTPUT", ")", "return", "cost", ";", "if", "(", "dep_class", "==", "ITANIUM_CLASS_ST", "||", "dep_class", "==", "ITANIUM_CLASS_STF", "||", "insn_class", "==", "ITANIUM_CLASS_ST", "||", "insn_class", "==", "ITANIUM_CLASS_STF", ")", "return", "0", ";", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

[ "ia64", "0", "0", "0" ]

[]

[ "<s>", "BitVector", "GBZ80RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "FLAGS", ")", ";", "Reserved", ".", "set", "(", "getFrameRegister", "(", "MF", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GBZ80::PC", "GBZ80::SP", "GBZ80::FLAGS" ]

[]

[ "<s>", "int", "M68kFrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "MergeWithPrevious", ")", "const", "{", "if", "(", "(", "MergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "MergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "MergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "MergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "!", "MergeWithPrevious", "&&", "NI", "!=", "MBB", ".", "end", "(", ")", "&&", "NI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", "{", "return", "Offset", ";", "}", "if", "(", "Opc", "==", "M68k", "::", "ADD32ai", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "MergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "Opc", "==", "M68k", "::", "SUB32ai", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "MergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "M68k", "M68k", "0", "0", "M68k::ADD32ai", "0", "1", "2", "M68k::SUB32ai", "0", "1", "2" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "DenseSet", "<", "const", "char", "*", ">", "Allowed", "(", "{", "&", "AAAMDAttributes", "::", "ID", ",", "&", "AAAMDWorkGroupSize", "::", "ID", ",", "&", "AACallEdges", "::", "ID", "}", ")", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "CGUpdater", ",", "&", "Allowed", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAAMDWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "unsigned", "int", "nds32_dbx_register_number", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "NDS32_IS_FPR_REGNUM", "(", "regno", ")", ")", "return", "regno", "+", "4", ";", "return", "regno", ";", "}", "</s>" ]

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

[ "nds32", "4" ]

[]

[ "<s>", "bool", "ARMDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintCode", "==", "'m'", "&&", "\"unexpected asm memory constraint\"", ")", ";", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"unexpected asm memory constraint\"" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreISel", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", ")", "PM", ".", "add", "(", "createARMGlobalMergePass", "(", "getTargetLowering", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load0", ",", "SDNode", "*", "Load1", ",", "int64_t", "Offset0", ",", "int64_t", "Offset1", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "Offset1", ">", "Offset0", "&&", "\"Second offset should be larger than first offset!\"", ")", ";", "return", "(", "NumLoads", "<=", "16", "&&", "(", "Offset1", "-", "Offset0", ")", "<", "64", ")", ";", "}", "</s>" ]

[ "shouldScheduleLoadsNear", "-", "This", "is", "a", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "(", "in", "conjunction", "with", "areLoadsFromSameBasePtr", ")", "if", "two", "loads", "should", "be", "scheduled", "togther", "." ]

[ "AMDGPU", "AMDGPU", "\"Second offset should be larger than first offset!\"", "16", "64" ]

[]

[ "<s>", "bool", "NyuziTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "Refs", "=", "AvailableDomains", "=", "Dist", "=", "0", ";", "Instrs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "X86", "0" ]

[]

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

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

[ "AZPR", "AZPR" ]

[]

[ "<s>", "StringRef", "AArch64NamedImmMapper", "::", "toString", "(", "uint32_t", "Value", ",", "const", "FeatureBitset", "&", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumMappings", ";", "++", "i", ")", "{", "if", "(", "Mappings", "[", "i", "]", ".", "isValueEqual", "(", "Value", ",", "FeatureBits", ")", ")", "{", "Valid", "=", "true", ";", "return", "Mappings", "[", "i", "]", ".", "Name", ";", "}", "}", "Valid", "=", "false", ";", "return", "StringRef", "(", ")", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

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

[]

[ "<s>", "static", "rtx", "frv_expand_prefetches", "(", "enum", "insn_code", "icode", ",", "tree", "call", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "force_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Expand", "prefetch", "builtins", ".", "These", "take", "a", "single", "address", "as", "argument", "." ]

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

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "unsigned", "LowGPR", "=", "ZFI", "->", "getLowSavedGPR", "(", ")", ";", "unsigned", "HighGPR", "=", "ZFI", "->", "getHighSavedGPR", "(", ")", ";", "unsigned", "StartOffset", "=", "RegSpillOffsets", "[", "LowGPR", "]", ";", "if", "(", "LowGPR", ")", "{", "assert", "(", "LowGPR", "!=", "HighGPR", "&&", "\"Should be loading %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HasFP", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "StartOffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "LowGPR", "&&", "Reg", "!=", "HighGPR", "&&", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "\"Should be loading %r15 and something else\"", "SystemZ::LMG", "SystemZ::R11D", "SystemZ::R15D", "0", "SystemZ::GR64BitRegClass" ]

[]

[ "<s>", "bool", "RV16KInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode!\"", ")", ";", "case", "RV16K", "::", "Bcc", ":", "case", "RV16K", "::", "BccI", ":", "return", "isInt", "<", "8", ">", "(", "BrOffset", "-", "2", ")", ";", "case", "RV16K", "::", "J", ":", "case", "RV16K", "::", "JAL", ":", "return", "isInt", "<", "16", ">", "(", "BrOffset", ")", ";", "}", "}", "</s>" ]

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

[ "RV16K", "RV16K", "\"Unexpected opcode!\"", "RV16K::Bcc", "RV16K::BccI", "8", "2", "RV16K::J", "RV16K::JAL", "16" ]

[]

[ "<s>", "uint64_t", "MipsFrameLowering", "::", "estimateStackSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "Offset", "=", "std", "::", "max", "(", "Offset", ",", "-", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "const", "MCPhysReg", "*", "R", "=", "TRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "{", "unsigned", "Size", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "*", "R", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "Size", ",", "Size", ")", ";", "}", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "MFI", "->", "getObjectIndexEnd", "(", ")", "||", "MaxAlign", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getObjectSize", "(", "I", ")", ",", "MaxAlign", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "=", "RoundUpToAlignment", "(", "Offset", "+", "MFI", "->", "getMaxCallFrameSize", "(", ")", ",", "std", "::", "max", "(", "MaxAlign", ",", "getStackAlignment", "(", ")", ")", ")", ";", "return", "RoundUpToAlignment", "(", "Offset", ",", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_setup_reg_addr_masks", "(", "void", ")", "{", "ssize_t", "rc", ",", "reg", ",", "m", ",", "nregs", ";", "addr_mask_type", "any_addr_mask", ",", "addr_mask", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "{", "machine_mode", "m2", "=", "(", "machine_mode", ")", "m", ";", "bool", "complex_p", "=", "false", ";", "bool", "small_int_p", "=", "(", "m2", "==", "QImode", "||", "m2", "==", "HImode", "||", "m2", "==", "SImode", ")", ";", "size_t", "msize", ";", "if", "(", "COMPLEX_MODE_P", "(", "m2", ")", ")", "{", "complex_p", "=", "true", ";", "m2", "=", "GET_MODE_INNER", "(", "m2", ")", ";", "}", "msize", "=", "GET_MODE_SIZE", "(", "m2", ")", ";", "bool", "indexed_only_p", "=", "(", "m", "==", "SDmode", "&&", "TARGET_NO_SDMODE_STACK", ")", ";", "any_addr_mask", "=", "0", ";", "for", "(", "rc", "=", "FIRST_RELOAD_REG_CLASS", ";", "rc", "<=", "LAST_RELOAD_REG_CLASS", ";", "rc", "++", ")", "{", "addr_mask", "=", "0", ";", "reg", "=", "reload_reg_map", "[", "rc", "]", ".", "reg", ";", "if", "(", "reg", ">=", "0", "&&", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "reg", "]", ")", "{", "bool", "small_int_vsx_p", "=", "(", "small_int_p", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", ")", ";", "nregs", "=", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "reg", "]", ";", "addr_mask", "|=", "RELOAD_REG_VALID", ";", "if", "(", "small_int_vsx_p", ")", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "else", "if", "(", "nregs", ">", "1", "||", "m", "==", "BLKmode", "||", "complex_p", ")", "addr_mask", "|=", "RELOAD_REG_MULTIPLE", ";", "else", "addr_mask", "|=", "RELOAD_REG_INDEXED", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "rc", "==", "RELOAD_REG_FPR", ")", "&&", "msize", "<=", "8", "&&", "!", "VECTOR_MODE_P", "(", "m2", ")", "&&", "!", "FLOAT128_VECTOR_P", "(", "m2", ")", "&&", "!", "complex_p", "&&", "(", "m", "!=", "E_DFmode", "||", "!", "TARGET_VSX", ")", "&&", "(", "m", "!=", "E_SFmode", "||", "!", "TARGET_P8_VECTOR", ")", "&&", "!", "small_int_vsx_p", ")", "{", "addr_mask", "|=", "RELOAD_REG_PRE_INCDEC", ";", "switch", "(", "m", ")", "{", "default", ":", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "TARGET_POWERPC64", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "case", "E_DFmode", ":", "case", "E_DDmode", ":", "if", "(", "TARGET_DF_INSN", ")", "addr_mask", "|=", "RELOAD_REG_PRE_MODIFY", ";", "break", ";", "}", "}", "}", "if", "(", "(", "addr_mask", "!=", "0", ")", "&&", "!", "indexed_only_p", "&&", "msize", "<=", "8", "&&", "(", "rc", "==", "RELOAD_REG_GPR", "||", "(", "(", "msize", "==", "8", "||", "m2", "==", "SFmode", ")", "&&", "(", "rc", "==", "RELOAD_REG_FPR", "||", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "TARGET_P9_VECTOR", ")", ")", ")", ")", ")", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "else", "if", "(", "(", "addr_mask", "!=", "0", ")", "&&", "!", "indexed_only_p", "&&", "msize", "==", "16", "&&", "TARGET_P9_VECTOR", "&&", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "m2", ")", "||", "(", "m2", "==", "TImode", "&&", "TARGET_VSX", ")", ")", ")", "{", "addr_mask", "|=", "RELOAD_REG_OFFSET", ";", "if", "(", "rc", "==", "RELOAD_REG_FPR", "||", "rc", "==", "RELOAD_REG_VMX", ")", "addr_mask", "|=", "RELOAD_REG_QUAD_OFFSET", ";", "}", "if", "(", "rc", "==", "RELOAD_REG_VMX", "&&", "msize", "==", "16", "&&", "(", "addr_mask", "&", "RELOAD_REG_VALID", ")", "!=", "0", ")", "addr_mask", "|=", "RELOAD_REG_AND_M16", ";", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", "=", "addr_mask", ";", "any_addr_mask", "|=", "addr_mask", ";", "}", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "=", "any_addr_mask", ";", "}", "}", "</s>" ]

[ "Update", "the", "addr", "mask", "bits", "in", "reg_addr", "to", "help", "secondary", "reload", "and", "go", "if", "legitimate", "address", "support", "to", "figure", "out", "the", "appropriate", "addressing", "to", "use", "." ]

[ "rs6000", "0", "0", "0", "0", "1", "8", "0", "8", "8", "0", "16", "16", "0" ]

[]

[ "<s>", "void", "Initialize", "(", "const", "MachineFunction", "&", "MF", ",", "bool", "isPIC", ")", "{", "IsPIC", "=", "isPIC", ";", "}", "</s>" ]

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

[ "Sparc" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "std", "::", "vector", "<", "MachineInstr", "const", "*", ">", "BundleMIs", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ";", "++", "MII", ";", "unsigned", "int", "IgnoreCount", "=", "0", ";", "while", "(", "MII", "!=", "MBB", "->", "end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "const", "MachineInstr", "*", "MInst", "=", "MII", ";", "if", "(", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "{", "IgnoreCount", "++", ";", "++", "MII", ";", "continue", ";", "}", "BundleMIs", ".", "push_back", "(", "MInst", ")", ";", "++", "MII", ";", "}", "unsigned", "Size", "=", "BundleMIs", ".", "size", "(", ")", ";", "assert", "(", "(", "Size", "+", "IgnoreCount", ")", "==", "MI", "->", "getBundleSize", "(", ")", "&&", "\"Corrupt Bundle!\"", ")", ";", "for", "(", "unsigned", "Index", "=", "0", ";", "Index", "<", "Size", ";", "Index", "++", ")", "{", "HexagonMCInst", "MCI", ";", "HexagonLowerToMC", "(", "BundleMIs", "[", "Index", "]", ",", "MCI", ",", "*", "this", ")", ";", "HexagonMCInst", "::", "AppendImplicitOperands", "(", "MCI", ")", ";", "MCI", ".", "setPacketBegin", "(", "Index", "==", "0", ")", ";", "MCI", ".", "setPacketEnd", "(", "Index", "==", "(", "Size", "-", "1", ")", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "}", "else", "{", "HexagonMCInst", "MCI", ";", "HexagonLowerToMC", "(", "MI", ",", "MCI", ",", "*", "this", ")", ";", "HexagonMCInst", "::", "AppendImplicitOperands", "(", "MCI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "MCI", ".", "setPacketBegin", "(", "true", ")", ";", "MCI", ".", "setPacketEnd", "(", "true", ")", ";", "}", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "return", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Corrupt Bundle!\"", "0", "Hexagon", "Hexagon", "Hexagon", "0", "1", "Hexagon", "Hexagon", "Hexagon", "Hexagon::ENDLOOP0" ]

[]

[ "<s>", "bool", "TLCS900TargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "if", "(", "LD", "->", "getExtensionType", "(", ")", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "false", ";", "EVT", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "if", "(", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "RHSC", "=", "RHS", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i16", "&&", "RHSC", "!=", "2", ")", "||", "(", "VT", "==", "MVT", "::", "i8", "&&", "RHSC", "!=", "1", ")", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "VT", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "TLCS900", "TLCS900", "ISD::MemIndexedMode", "ISD::NON_EXTLOAD", "MVT::i8", "MVT::i16", "ISD::ADD", "1", "MVT::i16", "2", "MVT::i8", "1", "0", "ISD::POST_INC" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "std", "::", "max", "(", "(", "VT", ".", "getSizeInBits", "(", ")", "/", "(", "Subtarget", ".", "isABI_O32", "(", ")", "?", "32", ":", "64", ")", ")", ",", "1U", ")", ";", "return", "MipsTargetLowering", "::", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "Mips", "Mips", "32", "64", "1U", "Mips" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SparcRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "return", "Subtarget", ".", "is64Bit", "(", ")", "?", "&", "SP", "::", "I64RegsRegClass", ":", "&", "SP", "::", "IntRegsRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::IntRegsRegClass" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "auto", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFixed", "=", "MFI", ".", "getNumFixedObjects", "(", ")", ";", "bool", "HasPrealloc", "=", "const_cast", "<", "MachineFrameInfo", "&", ">", "(", "MFI", ")", ".", "getLocalFrameObjectCount", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "(", "HasFixed", "||", "HasPrealloc", ")", "&&", "(", "HasAlloca", "||", "HasExtraAlign", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "0", ")", "{", "if", "(", "EnableStackOVFSanitizer", "||", "UseAllocframe", ")", "return", "true", ";", "}", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasClobberLR", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "arm_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "\"\\t.syntax unified\\n\"", ")", ";", "if", "(", "TARGET_ARM", ")", "{", "fprintf", "(", "f", ",", "\"\\t.arm\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\t%r, [%r, #0]\\n\"", ",", "STATIC_CHAIN_REGNUM", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\t%r, [%r, #0]\\n\"", ",", "PC_REGNUM", ",", "PC_REGNUM", ")", ";", "}", "else", "if", "(", "TARGET_THUMB2", ")", "{", "fprintf", "(", "f", ",", "\"\\t.thumb\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", ",", "STATIC_CHAIN_REGNUM", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", ",", "PC_REGNUM", ",", "PC_REGNUM", ")", ";", "}", "else", "{", "ASM_OUTPUT_ALIGN", "(", "f", ",", "2", ")", ";", "fprintf", "(", "f", ",", "\"\\t.code\\t16\\n\"", ")", ";", "fprintf", "(", "f", ",", "\".Ltrampoline_start:\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tpush\\t{r0, r1}\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\tr0, [%r, #8]\\n\"", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tmov\\t%r, r0\\n\"", ",", "STATIC_CHAIN_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\tr0, [%r, #8]\\n\"", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tstr\\tr0, [%r, #4]\\n\"", ",", "SP_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tpop\\t{r0, %r}\\n\"", ",", "PC_REGNUM", ")", ";", "}", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "the", "variable", "parts", ".", "On", "the", "ARM", ",", "(", "if", "r8", "is", "the", "static", "chain", "regnum", ",", "and", "remembering", "that", "referencing", "pc", "adds", "an", "offset", "of", "8", ")", "the", "trampoline", "looks", "like", ":", "ldr", "r8", ",", "[", "pc", ",", "#", "0", "]", "ldr", "pc", ",", "[", "pc", "]", ".word", "static", "chain", "value", ".word", "function", "'s", "address", "XXX", "FIXME", ":", "When", "the", "trampoline", "returns", ",", "r8", "will", "be", "clobbered", "." ]

[ "arm", "\"\\t.syntax unified\\n\"", "\"\\t.arm\\n\"", "\"\\tldr\\t%r, [%r, #0]\\n\"", "\"\\tldr\\t%r, [%r, #0]\\n\"", "\"\\t.thumb\\n\"", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", "2", "\"\\t.code\\t16\\n\"", "\".Ltrampoline_start:\\n\"", "\"\\tpush\\t{r0, r1}\\n\"", "\"\\tldr\\tr0, [%r, #8]\\n\"", "\"\\tmov\\t%r, r0\\n\"", "\"\\tldr\\tr0, [%r, #8]\\n\"", "\"\\tstr\\tr0, [%r, #4]\\n\"", "\"\\tpop\\t{r0, %r}\\n\"" ]

[]

[ "<s>", "const", "char", "*", "BPFTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "BPFISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "BPFISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "BPFISD", "::", "RET_FLAG", ":", "return", "\"BPFISD::RET_FLAG\"", ";", "case", "BPFISD", "::", "CALL", ":", "return", "\"BPFISD::CALL\"", ";", "case", "BPFISD", "::", "SELECT_CC", ":", "return", "\"BPFISD::SELECT_CC\"", ";", "case", "BPFISD", "::", "BR_CC", ":", "return", "\"BPFISD::BR_CC\"", ";", "case", "BPFISD", "::", "Wrapper", ":", "return", "\"BPFISD::Wrapper\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "BPF", "BPF", "BPFISD::NodeType", "BPFISD::FIRST_NUMBER", "BPFISD::RET_FLAG", "\"BPFISD::RET_FLAG\"", "BPFISD::CALL", "\"BPFISD::CALL\"", "BPFISD::SELECT_CC", "\"BPFISD::SELECT_CC\"", "BPFISD::BR_CC", "\"BPFISD::BR_CC\"", "BPFISD::Wrapper", "\"BPFISD::Wrapper\"" ]

[]

[ "<s>", "static", "tree", "bpf_core_newdecl", "(", "tree", "type", ")", "{", "tree", "rettype", "=", "build_function_type_list", "(", "type", ",", "type", ",", "NULL", ")", ";", "char", "name", "[", "80", "]", ";", "int", "len", "=", "snprintf", "(", "name", ",", "sizeof", "(", "name", ")", ",", "\"%s\"", ",", "\"__builtin_pai_\"", ")", ";", "static", "unsigned", "long", "cnt", "=", "0", ";", "len", "=", "snprintf", "(", "name", "+", "len", ",", "sizeof", "(", "name", ")", "-", "len", ",", "\"%lu\"", ",", "cnt", "++", ")", ";", "return", "add_builtin_function_ext_scope", "(", "name", ",", "rettype", ",", "-", "1", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Synthesize", "a", "new", "builtin", "function", "declaration", "with", "signature", "TYPE", ".", "Used", "by", "bpf_resolve_overloaded_builtin", "to", "resolve", "calls", "to", "__builtin_preserve_access_index", "." ]

[ "bpf", "80", "\"%s\"", "\"__builtin_pai_\"", "0", "\"%lu\"", "1" ]

[]

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

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

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

[]

[ "<s>", "MachineSDNode", "*", "SITargetLowering", "::", "buildRSRC", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Ptr", ",", "uint32_t", "RsrcDword1", ",", "uint64_t", "RsrcDword2And3", ")", "const", "{", "SDValue", "PtrLo", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "SDValue", "PtrHi", "=", "DAG", ".", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "if", "(", "RsrcDword1", ")", "{", "PtrHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "S_OR_B32", ",", "DL", ",", "MVT", "::", "i32", ",", "PtrHi", ",", "DAG", ".", "getConstant", "(", "RsrcDword1", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "SDValue", "DataLo", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", "&", "UINT64_C", "(", "0xFFFFFFFF", ")", ")", ";", "SDValue", "DataHi", "=", "buildSMovImm32", "(", "DAG", ",", "DL", ",", "RsrcDword2And3", ">>", "32", ")", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "SReg_128RegClassID", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "PtrHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataLo", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub2", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DataHi", ",", "DAG", ".", "getTargetConstant", "(", "AMDGPU", "::", "sub3", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ";", "return", "DAG", ".", "getMachineNode", "(", "AMDGPU", "::", "REG_SEQUENCE", ",", "DL", ",", "MVT", "::", "v4i32", ",", "Ops", ")", ";", "}", "</s>" ]

[ "Return", "a", "resource", "descriptor", "with", "the", "'Add", "TID", "'", "bit", "enabled", "The", "TID", "(", "Thread", "ID", ")", "is", "multiplied", "by", "the", "stride", "value", "(", "bits", "[", "61:48", "]", "of", "the", "resource", "descriptor", ")", "to", "create", "an", "offset", ",", "which", "is", "added", "to", "the", "resource", "pointer", "." ]

[ "R600", "SI", "MVT::i32", "MVT::i32", "MVT::i32", "MVT::i32", "0", "0xFFFFFFFF", "32", "MVT::i32", "MVT::i32", "MVT::i32", "MVT::i32", "MVT::i32", "MVT::v4i32" ]

[]

[ "<s>", "rtx", "gen_scalar_move_mask", "(", "machine_mode", "mode", ")", "{", "rtx_vector_builder", "builder", "(", "mode", ",", "1", ",", "2", ")", ";", "builder", ".", "quick_push", "(", "const1_rtx", ")", ";", "builder", ".", "quick_push", "(", "const0_rtx", ")", ";", "return", "builder", ".", "build", "(", ")", ";", "}", "</s>" ]

[ "Get", "{", "...", ",0", ",", "0", ",", "0", ",", "...", ",", "0", ",", "0", ",", "0", ",", "1", "}", "mask", "." ]

[ "riscv", "1", "2" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI_end", "=", "MBB", ".", "end", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "STI", ".", "hasV4TOps", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "JMPR", "&&", "!", "DisableDeallocRet", ")", "{", "MBB", ".", "erase", "(", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI_end", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOC_RET_V4", ")", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOCFRAME", ")", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::JMPR", "Hexagon::DEALLOC_RET_V4", "Hexagon::DEALLOCFRAME" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectSize", "(", "FrameIdx", ")", ">=", "RC", "->", "getSize", "(", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "const", "char", "*", "NVPTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "NVPTXISD", "::", "CALL", ":", "return", "\"NVPTXISD::CALL\"", ";", "case", "NVPTXISD", "::", "RET_FLAG", ":", "return", "\"NVPTXISD::RET_FLAG\"", ";", "case", "NVPTXISD", "::", "Wrapper", ":", "return", "\"NVPTXISD::Wrapper\"", ";", "case", "NVPTXISD", "::", "DeclareParam", ":", "return", "\"NVPTXISD::DeclareParam\"", ";", "case", "NVPTXISD", "::", "DeclareScalarParam", ":", "return", "\"NVPTXISD::DeclareScalarParam\"", ";", "case", "NVPTXISD", "::", "DeclareRet", ":", "return", "\"NVPTXISD::DeclareRet\"", ";", "case", "NVPTXISD", "::", "DeclareRetParam", ":", "return", "\"NVPTXISD::DeclareRetParam\"", ";", "case", "NVPTXISD", "::", "PrintCall", ":", "return", "\"NVPTXISD::PrintCall\"", ";", "case", "NVPTXISD", "::", "LoadParam", ":", "return", "\"NVPTXISD::LoadParam\"", ";", "case", "NVPTXISD", "::", "LoadParamV2", ":", "return", "\"NVPTXISD::LoadParamV2\"", ";", "case", "NVPTXISD", "::", "LoadParamV4", ":", "return", "\"NVPTXISD::LoadParamV4\"", ";", "case", "NVPTXISD", "::", "StoreParam", ":", "return", "\"NVPTXISD::StoreParam\"", ";", "case", "NVPTXISD", "::", "StoreParamV2", ":", "return", "\"NVPTXISD::StoreParamV2\"", ";", "case", "NVPTXISD", "::", "StoreParamV4", ":", "return", "\"NVPTXISD::StoreParamV4\"", ";", "case", "NVPTXISD", "::", "StoreParamS32", ":", "return", "\"NVPTXISD::StoreParamS32\"", ";", "case", "NVPTXISD", "::", "StoreParamU32", ":", "return", "\"NVPTXISD::StoreParamU32\"", ";", "case", "NVPTXISD", "::", "CallArgBegin", ":", "return", "\"NVPTXISD::CallArgBegin\"", ";", "case", "NVPTXISD", "::", "CallArg", ":", "return", "\"NVPTXISD::CallArg\"", ";", "case", "NVPTXISD", "::", "LastCallArg", ":", "return", "\"NVPTXISD::LastCallArg\"", ";", "case", "NVPTXISD", "::", "CallArgEnd", ":", "return", "\"NVPTXISD::CallArgEnd\"", ";", "case", "NVPTXISD", "::", "CallVoid", ":", "return", "\"NVPTXISD::CallVoid\"", ";", "case", "NVPTXISD", "::", "CallVal", ":", "return", "\"NVPTXISD::CallVal\"", ";", "case", "NVPTXISD", "::", "CallSymbol", ":", "return", "\"NVPTXISD::CallSymbol\"", ";", "case", "NVPTXISD", "::", "Prototype", ":", "return", "\"NVPTXISD::Prototype\"", ";", "case", "NVPTXISD", "::", "MoveParam", ":", "return", "\"NVPTXISD::MoveParam\"", ";", "case", "NVPTXISD", "::", "StoreRetval", ":", "return", "\"NVPTXISD::StoreRetval\"", ";", "case", "NVPTXISD", "::", "StoreRetvalV2", ":", "return", "\"NVPTXISD::StoreRetvalV2\"", ";", "case", "NVPTXISD", "::", "StoreRetvalV4", ":", "return", "\"NVPTXISD::StoreRetvalV4\"", ";", "case", "NVPTXISD", "::", "PseudoUseParam", ":", "return", "\"NVPTXISD::PseudoUseParam\"", ";", "case", "NVPTXISD", "::", "RETURN", ":", "return", "\"NVPTXISD::RETURN\"", ";", "case", "NVPTXISD", "::", "CallSeqBegin", ":", "return", "\"NVPTXISD::CallSeqBegin\"", ";", "case", "NVPTXISD", "::", "CallSeqEnd", ":", "return", "\"NVPTXISD::CallSeqEnd\"", ";", "case", "NVPTXISD", "::", "CallPrototype", ":", "return", "\"NVPTXISD::CallPrototype\"", ";", "case", "NVPTXISD", "::", "LoadV2", ":", "return", "\"NVPTXISD::LoadV2\"", ";", "case", "NVPTXISD", "::", "LoadV4", ":", "return", "\"NVPTXISD::LoadV4\"", ";", "case", "NVPTXISD", "::", "LDGV2", ":", "return", "\"NVPTXISD::LDGV2\"", ";", "case", "NVPTXISD", "::", "LDGV4", ":", "return", "\"NVPTXISD::LDGV4\"", ";", "case", "NVPTXISD", "::", "LDUV2", ":", "return", "\"NVPTXISD::LDUV2\"", ";", "case", "NVPTXISD", "::", "LDUV4", ":", "return", "\"NVPTXISD::LDUV4\"", ";", "case", "NVPTXISD", "::", "StoreV2", ":", "return", "\"NVPTXISD::StoreV2\"", ";", "case", "NVPTXISD", "::", "StoreV4", ":", "return", "\"NVPTXISD::StoreV4\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "NVPTX", "NVPTX", "0", "NVPTXISD::CALL", "\"NVPTXISD::CALL\"", "NVPTXISD::RET_FLAG", "\"NVPTXISD::RET_FLAG\"", "NVPTXISD::Wrapper", "\"NVPTXISD::Wrapper\"", "NVPTXISD::DeclareParam", "\"NVPTXISD::DeclareParam\"", "NVPTXISD::DeclareScalarParam", "\"NVPTXISD::DeclareScalarParam\"", "NVPTXISD::DeclareRet", "\"NVPTXISD::DeclareRet\"", "NVPTXISD::DeclareRetParam", "\"NVPTXISD::DeclareRetParam\"", "NVPTXISD::PrintCall", "\"NVPTXISD::PrintCall\"", "NVPTXISD::LoadParam", "\"NVPTXISD::LoadParam\"", "NVPTXISD::LoadParamV2", "\"NVPTXISD::LoadParamV2\"", "NVPTXISD::LoadParamV4", "\"NVPTXISD::LoadParamV4\"", "NVPTXISD::StoreParam", "\"NVPTXISD::StoreParam\"", "NVPTXISD::StoreParamV2", "\"NVPTXISD::StoreParamV2\"", "NVPTXISD::StoreParamV4", "\"NVPTXISD::StoreParamV4\"", "NVPTXISD::StoreParamS32", "\"NVPTXISD::StoreParamS32\"", "NVPTXISD::StoreParamU32", "\"NVPTXISD::StoreParamU32\"", "NVPTXISD::CallArgBegin", "\"NVPTXISD::CallArgBegin\"", "NVPTXISD::CallArg", "\"NVPTXISD::CallArg\"", "NVPTXISD::LastCallArg", "\"NVPTXISD::LastCallArg\"", "NVPTXISD::CallArgEnd", "\"NVPTXISD::CallArgEnd\"", "NVPTXISD::CallVoid", "\"NVPTXISD::CallVoid\"", "NVPTXISD::CallVal", "\"NVPTXISD::CallVal\"", "NVPTXISD::CallSymbol", "\"NVPTXISD::CallSymbol\"", "NVPTXISD::Prototype", "\"NVPTXISD::Prototype\"", "NVPTXISD::MoveParam", "\"NVPTXISD::MoveParam\"", "NVPTXISD::StoreRetval", "\"NVPTXISD::StoreRetval\"", "NVPTXISD::StoreRetvalV2", "\"NVPTXISD::StoreRetvalV2\"", "NVPTXISD::StoreRetvalV4", "\"NVPTXISD::StoreRetvalV4\"", "NVPTXISD::PseudoUseParam", "\"NVPTXISD::PseudoUseParam\"", "NVPTXISD::RETURN", "\"NVPTXISD::RETURN\"", "NVPTXISD::CallSeqBegin", "\"NVPTXISD::CallSeqBegin\"", "NVPTXISD::CallSeqEnd", "\"NVPTXISD::CallSeqEnd\"", "NVPTXISD::CallPrototype", "\"NVPTXISD::CallPrototype\"", "NVPTXISD::LoadV2", "\"NVPTXISD::LoadV2\"", "NVPTXISD::LoadV4", "\"NVPTXISD::LoadV4\"", "NVPTXISD::LDGV2", "\"NVPTXISD::LDGV2\"", "NVPTXISD::LDGV4", "\"NVPTXISD::LDGV4\"", "NVPTXISD::LDUV2", "\"NVPTXISD::LDUV2\"", "NVPTXISD::LDUV4", "\"NVPTXISD::LDUV4\"", "NVPTXISD::StoreV2", "\"NVPTXISD::StoreV2\"", "NVPTXISD::StoreV4", "\"NVPTXISD::StoreV4\"" ]

[]

[ "<s>", "static", "bool", "bfin_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "other", "eliminations", "are", "valid", "." ]

[ "bfin" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "MipsDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MipsDisassembler", "*", ">", "(", "D", ")", ";", "const", "MCRegisterInfo", "*", "RegInfo", "=", "Dis", "->", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "*", "(", "RegInfo", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

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

[]

[ "<s>", "int", "mt_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "xinsn", ",", "int", "strict", ")", "{", "if", "(", "mt_legitimate_simple_address_p", "(", "mode", ",", "xinsn", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "(", "mode", ")", "==", "SImode", "&&", "GET_CODE", "(", "xinsn", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "xinsn", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "xinsn", ",", "1", ")", ")", "==", "-", "3", ")", "return", "mt_legitimate_simple_address_p", "(", "mode", ",", "XEXP", "(", "xinsn", ",", "0", ")", ",", "strict", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Helper", "function", "of", "GO_IF_LEGITIMATE_ADDRESS", ".", "Return", "non-zero", "if", "XINSN", "is", "a", "legitimate", "address", "on", "MT", "." ]

[ "mt", "1", "1", "1", "3", "0", "0" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

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

[ "MSP430" ]

[]

[ "<s>", "int", "shl_sext_kind", "(", "rtx", "left_rtx", ",", "rtx", "size_rtx", ",", "int", "*", "costp", ")", "{", "int", "left", ",", "size", ",", "insize", ",", "ext", ";", "int", "cost", "=", "0", ",", "best_cost", ";", "int", "kind", ";", "left", "=", "INTVAL", "(", "left_rtx", ")", ";", "size", "=", "INTVAL", "(", "size_rtx", ")", ";", "insize", "=", "size", "-", "left", ";", "gcc_assert", "(", "insize", ">", "0", ")", ";", "kind", "=", "0", ";", "best_cost", "=", "ashl_lshr_seq", "[", "32", "-", "insize", "]", ".", "insn_count", "+", "ashl_lshr_seq", "[", "32", "-", "size", "]", ".", "insn_count", ";", "if", "(", "size", "<=", "16", ")", "{", "cost", "=", "ashl_lshr_seq", "[", "16", "-", "insize", "]", ".", "insn_count", "+", "1", "+", "ashl_lshr_seq", "[", "16", "-", "size", "]", ".", "insn_count", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "5", ";", "best_cost", "=", "cost", ";", "}", "}", "for", "(", "ext", "=", "16", ";", "ext", ">=", "insize", ";", "ext", "-=", "8", ")", "{", "if", "(", "ext", "<=", "size", ")", "{", "cost", "=", "ext_ashl_lshr_seq", "[", "ext", "-", "insize", "]", ".", "insn_count", "+", "1", "+", "ashl_lshr_seq", "[", "size", "-", "ext", "]", ".", "insn_count", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "ext", "/", "(", "unsigned", ")", "8", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "EXT_SHIFT_SIGNED", "(", "size", "-", "ext", ")", ")", "cost", "=", "ext_ashl_lshr_seq", "[", "ext", "-", "insize", "]", ".", "insn_count", "+", "ext_ashl_lshr_seq", "[", "size", "-", "ext", "]", ".", "insn_count", "+", "1", ";", "else", "if", "(", "size", "<=", "16", ")", "cost", "=", "ext_ashl_lshr_seq", "[", "ext", "-", "insize", "]", ".", "insn_count", "+", "1", "+", "ext_ashl_lshr_seq", "[", "size", ">", "ext", "?", "size", "-", "ext", ":", "ext", "-", "size", "]", ".", "insn_count", "+", "1", ";", "else", "continue", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "ext", "/", "(", "unsigned", ")", "8", "+", "2", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "insize", "<", "8", ")", "{", "cost", "=", "3", "+", "ashl_lshr_seq", "[", "left", "]", ".", "insn_count", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "6", ";", "best_cost", "=", "cost", ";", "}", "if", "(", "left", "<", "31", ")", "{", "cost", "=", "3", "+", "ext_ashl_lshr_seq", "[", "left", "+", "1", "]", ".", "insn_count", "+", "1", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "7", ";", "best_cost", "=", "cost", ";", "}", "}", "}", "if", "(", "TARGET_DYNSHIFT", ")", "{", "cost", "=", "ashl_lshr_seq", "[", "32", "-", "insize", "]", ".", "insn_count", "+", "1", "+", "SH_DYNAMIC_SHIFT_COST", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "0", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "costp", ")", "*", "costp", "=", "cost", ";", "return", "kind", ";", "}", "</s>" ]

[ "Try", "to", "find", "a", "good", "way", "to", "implement", "the", "combiner", "pattern", "[", "(", "set", "(", "match_operand", ":", "SI", "0", "``", "register_operand", "''", "``", "=r", "''", ")", "(", "sign_extract", ":", "SI", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "1", "``", "register_operand", "''", "``", "r", "''", ")", "(", "match_operand", ":", "SI", "2", "``", "const_int_operand", "''", "``", "n", "''", ")", "(", "match_operand", ":", "SI", "3", "``", "const_int_operand", "''", "``", "n", "''", ")", "(", "const_int", "0", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "T_REG", ")", ")", "]", "LEFT_RTX", "is", "operand", "2", "in", "the", "above", "pattern", ",", "and", "SIZE_RTX", "is", "operand", "3.", "return", "0", "for", "simple", "left", "/", "right", "shift", "combination", ".", "return", "1", "for", "left", "shift", "/", "8", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "2", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "3", "for", "left", "shift", "/", "8", "bit", "sign", "extend", "/", "shift", "/", "sign", "extend", ".", "return", "4", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "shift", "/", "sign", "extend", ".", "return", "5", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "right", "shift", "return", "6", "for", "<", "8", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "7", "for", "<", "8", "bit", "sign", "extend", "/", "left", "shift", "/", "single", "right", "shift", ".", "If", "COSTP", "is", "nonzero", ",", "assign", "the", "calculated", "cost", "to", "*", "COSTP", "." ]

[ "sh", "0", "0", "0", "32", "32", "16", "16", "1", "16", "5", "16", "8", "1", "8", "1", "16", "1", "1", "8", "2", "8", "3", "6", "31", "3", "1", "1", "7", "32", "1", "0" ]

[]

[ "<s>", "int", "leaf_return_peephole_ok", "(", ")", "{", "return", "(", "actual_fsize", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "a", "return", "peephole", "merging", "return", "with", "setting", "of", "output", "register", "is", "ok", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "addPass", "(", "createAArch64BranchRelaxation", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", "&&", "EnableLowerKernelArguments", ")", "addPass", "(", "createAMDGPULowerKernelArgumentsPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "isPassEnabled", "(", "EnableLoadStoreVectorizer", ")", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "WebAssembly", "::", "NoRegister", "+", "1", ";", "PReg", "<", "WebAssembly", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "WebAssembly", "::", "VALUE_STACK", "||", "PReg", "==", "WebAssembly", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "WebAssembly", "::", "NoRegister", ";", "for", "(", "MachineOperand", "&", "MO", ":", "llvm", "::", "make_early_inc_range", "(", "MRI", ".", "reg_operands", "(", "PReg", ")", ")", ")", "{", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "WebAssembly", "::", "NoRegister", ")", "{", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "PReg", "==", "TRI", ".", "getFrameRegister", "(", "MF", ")", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "FI", "->", "isFrameBaseVirtual", "(", ")", ")", ";", "FI", "->", "setFrameBaseVreg", "(", "VReg", ")", ";", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"replacing preg \"", "<<", "PReg", "<<", "\" with \"", "<<", "VReg", "<<", "\" (\"", "<<", "Register", "::", "virtReg2Index", "(", "VReg", ")", "<<", "\")\\n\"", ";", "}", ")", ";", "}", "}", "MO", ".", "setReg", "(", "VReg", ")", ";", "if", "(", "MO", ".", "getParent", "(", ")", "->", "isDebugValue", "(", ")", ")", "MO", ".", "setIsDebug", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "WebAssembly::NoRegister", "1", "WebAssembly::NUM_TARGET_REGS", "WebAssembly::VALUE_STACK", "WebAssembly::ARGUMENTS", "WebAssembly::NoRegister", "WebAssembly::NoRegister", "WebAssembly", "\"replacing preg \"", "\" with \"", "\" (\"", "\")\\n\"" ]

[]

[ "<s>", "static", "void", "mips_set_compression_mode", "(", "unsigned", "int", "compression_mode", ")", "{", "if", "(", "compression_mode", "==", "old_compression_mode", ")", "return", ";", "target_flags", "=", "mips_base_target_flags", ";", "flag_schedule_insns", "=", "mips_base_schedule_insns", ";", "flag_reorder_blocks_and_partition", "=", "mips_base_reorder_blocks_and_partition", ";", "flag_move_loop_invariants", "=", "mips_base_move_loop_invariants", ";", "align_loops", "=", "mips_base_align_loops", ";", "align_jumps", "=", "mips_base_align_jumps", ";", "align_functions", "=", "mips_base_align_functions", ";", "target_flags", "&=", "~", "(", "MASK_MIPS16", "|", "MASK_MICROMIPS", ")", ";", "target_flags", "|=", "compression_mode", ";", "if", "(", "compression_mode", "&", "MASK_MIPS16", ")", "{", "target_flags", "|=", "MASK_MIPS16", ";", "target_flags", "&=", "~", "MASK_SYNCI", ";", "flag_schedule_insns", "=", "0", ";", "flag_reorder_blocks_and_partition", "=", "0", ";", "flag_move_loop_invariants", "=", "0", ";", "target_flags", "|=", "MASK_EXPLICIT_RELOCS", ";", "targetm", ".", "min_anchor_offset", "=", "0", ";", "targetm", ".", "max_anchor_offset", "=", "127", ";", "targetm", ".", "const_anchor", "=", "0", ";", "target_flags", "&=", "~", "MASK_RELAX_PIC_CALLS", ";", "target_flags", "&=", "~", "MASK_FIX_R4000", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_OLDABI", ")", "sorry", "(", "\"MIPS16 PIC for ABIs other than o32 and o64\"", ")", ";", "if", "(", "TARGET_XGOT", ")", "sorry", "(", "\"MIPS16 -mxgot code\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT_ABI", "&&", "!", "TARGET_OLDABI", ")", "sorry", "(", "\"hard-float MIPS16 code for ABIs other than o32 and o64\"", ")", ";", "}", "else", "{", "if", "(", "TARGET_MICROMIPS", ")", "target_flags", "&=", "~", "MASK_BRANCHLIKELY", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "align_loops", "==", "0", ")", "align_loops", "=", "8", ";", "if", "(", "align_jumps", "==", "0", ")", "align_jumps", "=", "8", ";", "if", "(", "align_functions", "==", "0", ")", "align_functions", "=", "8", ";", "}", "targetm", ".", "min_anchor_offset", "=", "-", "32768", ";", "targetm", ".", "max_anchor_offset", "=", "32767", ";", "targetm", ".", "const_anchor", "=", "0x8000", ";", "}", "mips_init_relocs", "(", ")", ";", "if", "(", "compression_mode", "&", "MASK_MIPS16", ")", "{", "if", "(", "!", "mips16_globals", ")", "mips16_globals", "=", "save_target_globals_default_opts", "(", ")", ";", "else", "restore_target_globals", "(", "mips16_globals", ")", ";", "}", "else", "if", "(", "compression_mode", "&", "MASK_MICROMIPS", ")", "{", "if", "(", "!", "micromips_globals", ")", "micromips_globals", "=", "save_target_globals_default_opts", "(", ")", ";", "else", "restore_target_globals", "(", "micromips_globals", ")", ";", "}", "else", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "old_compression_mode", "=", "compression_mode", ";", "}", "</s>" ]

[ "Set", "up", "the", "target-dependent", "global", "state", "for", "ISA", "mode", "COMPRESSION_MODE", ",", "which", "is", "either", "MASK_MIPS16", "or", "MASK_MICROMIPS", "." ]

[ "mips", "0", "0", "0", "0", "127", "0", "\"MIPS16 PIC for ABIs other than o32 and o64\"", "\"MIPS16 -mxgot code\"", "\"hard-float MIPS16 code for ABIs other than o32 and o64\"", "0", "8", "0", "8", "0", "8", "32768", "32767", "0x8000" ]

[]

[ "<s>", "bool", "BPFDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "!", "SelectAddr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "AluOp", "=", "CurDAG", "->", "getTargetConstant", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ")", ";", ";", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "AluOp", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::ADD", "MVT::i32" ]

[]

[ "<s>", "bool", "AMDGPUPromoteKernelArguments", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "MemorySSA", "&", "MSSA", "=", "getAnalysis", "<", "MemorySSAWrapperPass", ">", "(", ")", ".", "getMSSA", "(", ")", ";", "AliasAnalysis", "&", "AA", "=", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "return", "run", "(", "F", ",", "MSSA", ",", "AA", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "Thumb1FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "Thumb1InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Thumb1InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "Thumb1RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "Thumb1RegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "Amount", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</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", ")", "." ]

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "static", "int", "ep_memory_offset", "(", "enum", "machine_mode", "mode", ",", "int", "unsignedp", "ATTRIBUTE_UNUSED", ")", "{", "int", "max_offset", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "if", "(", "TARGET_SMALL_SLD", ")", "max_offset", "=", "(", "1", "<<", "4", ")", ";", "else", "if", "(", "TARGET_V850E", "&&", "(", "(", "unsignedp", "&&", "!", "TARGET_US_BIT_SET", ")", "||", "(", "!", "unsignedp", "&&", "TARGET_US_BIT_SET", ")", ")", ")", "max_offset", "=", "(", "1", "<<", "4", ")", ";", "else", "max_offset", "=", "(", "1", "<<", "7", ")", ";", "break", ";", "case", "HImode", ":", "if", "(", "TARGET_SMALL_SLD", ")", "max_offset", "=", "(", "1", "<<", "5", ")", ";", "else", "if", "(", "TARGET_V850E", "&&", "(", "(", "unsignedp", "&&", "!", "TARGET_US_BIT_SET", ")", "||", "(", "!", "unsignedp", "&&", "TARGET_US_BIT_SET", ")", ")", ")", "max_offset", "=", "(", "1", "<<", "5", ")", ";", "else", "max_offset", "=", "(", "1", "<<", "8", ")", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "max_offset", "=", "(", "1", "<<", "8", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "max_offset", ";", "}", "</s>" ]

[ "Return", "maximum", "offset", "supported", "for", "a", "short", "EP", "memory", "reference", "of", "mode", "MODE", "and", "signedness", "UNSIGNEDP", "." ]

[ "v850", "0", "1", "4", "1", "4", "1", "7", "1", "5", "1", "5", "1", "8", "1", "8" ]

[]

[ "<s>", "BitVector", "OR1KRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "OR1K", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "OR1K", "::", "R1", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "OR1K", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "OR1K", "::", "R9", ")", ";", "Reserved", ".", "set", "(", "OR1K", "::", "R10", ")", ";", "Reserved", ".", "set", "(", "OR1K", "::", "R16", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "getBaseRegister", "(", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::R0", "OR1K::R1", "OR1K::R2", "OR1K::R9", "OR1K::R10", "OR1K::R16" ]

[]

[ "<s>", "void", "s390_expand_merge", "(", "rtx", "target", ",", "rtx", "src1", ",", "rtx", "src2", ",", "bool", "high_p", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "opt_machine_mode", "opt_mode_2x", "=", "mode_for_vector", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "2", "*", "GET_MODE_NUNITS", "(", "mode", ")", ")", ";", "gcc_assert", "(", "opt_mode_2x", ".", "exists", "(", ")", ")", ";", "machine_mode", "mode_double_nelts", "=", "opt_mode_2x", ".", "require", "(", ")", ";", "rtx", "constv", "=", "s390_expand_merge_perm_const", "(", "mode", ",", "high_p", ")", ";", "src1", "=", "force_reg", "(", "GET_MODE", "(", "src1", ")", ",", "src1", ")", ";", "src2", "=", "force_reg", "(", "GET_MODE", "(", "src2", ")", ",", "src2", ")", ";", "rtx", "x", "=", "gen_rtx_VEC_CONCAT", "(", "mode_double_nelts", ",", "src1", ",", "src2", ")", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "x", ",", "constv", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "implement", "a", "vector", "merge", "operation", "of", "SRC1", "and", "SRC2", "which", "creates", "the", "result", "in", "TARGET", ".", "HIGH_P", "determines", "whether", "a", "merge", "hi", "or", "lo", "will", "be", "generated", "." ]

[ "s390", "2" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "RISCV", "\"Invalid type access!\"" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "is64bit", ")", ",", "DataLayout", "(", "Subtarget", ".", "getDataLayout", "(", ")", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "FrameLowering", "(", "Subtarget", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "bool", "ContiguousRegs", "=", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "uint16_t", "*", "SuperReg", "=", "TRI", "->", "getSuperRegisters", "(", "Reg", ")", ";", "assert", "(", "SuperReg", "[", "0", "]", "&&", "!", "SuperReg", "[", "1", "]", "&&", "\"Expected exactly one superreg\"", ")", ";", "bool", "CanUseDblStore", "=", "false", ";", "const", "TargetRegisterClass", "*", "SuperRegClass", "=", "0", ";", "if", "(", "ContiguousRegs", "&&", "(", "i", "<", "CSI", ".", "size", "(", ")", "-", "1", ")", ")", "{", "const", "uint16_t", "*", "SuperRegNext", "=", "TRI", "->", "getSuperRegisters", "(", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ")", ";", "assert", "(", "SuperRegNext", "[", "0", "]", "&&", "!", "SuperRegNext", "[", "1", "]", "&&", "\"Expected exactly one superreg\"", ")", ";", "SuperRegClass", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "SuperReg", "[", "0", "]", ")", ";", "CanUseDblStore", "=", "(", "SuperRegNext", "[", "0", "]", "==", "SuperReg", "[", "0", "]", ")", ";", "}", "if", "(", "CanUseDblStore", ")", "{", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "SuperReg", "[", "0", "]", ",", "true", ",", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", ",", "SuperRegClass", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "SuperReg", "[", "0", "]", ")", ";", "++", "i", ";", "}", "else", "{", "ContiguousRegs", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "0", "1", "\"Expected exactly one superreg\"", "0", "1", "1", "0", "1", "\"Expected exactly one superreg\"", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "RISCVAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode not expected!\"", ")", ";", "case", "RISCV", "::", "C_BEQZ", ":", "Res", ".", "setOpcode", "(", "RISCV", "::", "BEQ", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "RISCV", "::", "X0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "RISCV", "::", "C_BNEZ", ":", "Res", ".", "setOpcode", "(", "RISCV", "::", "BNE", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "RISCV", "::", "X0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "RISCV", "::", "C_J", ":", "Res", ".", "setOpcode", "(", "RISCV", "::", "JAL", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "RISCV", "::", "X0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "break", ";", "case", "RISCV", "::", "C_JAL", ":", "Res", ".", "setOpcode", "(", "RISCV", "::", "JAL", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "RISCV", "::", "X1", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Opcode not expected!\"", "RISCV::C_BEQZ", "RISCV::BEQ", "0", "RISCV::X0", "1", "RISCV::C_BNEZ", "RISCV::BNE", "0", "RISCV::X0", "1", "RISCV::C_J", "RISCV::JAL", "RISCV::X0", "0", "RISCV::C_JAL", "RISCV::JAL", "RISCV::X1", "0" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "bfin_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", ")", "&&", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", ")", "&&", "mode1", "!=", "BImode", "&&", "mode2", "!=", "BImode", "&&", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

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

[ "bfin" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "DestReg", ")", "&&", "PPC", "::", "VSLRCRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "PPC", "::", "sub_64", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "SrcReg", "==", "SuperReg", ")", "return", ";", "DestReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "DestReg", ")", "&&", "PPC", "::", "VSHRCRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "PPC", "::", "sub_128", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "SrcReg", "==", "SuperReg", ")", "return", ";", "DestReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSLRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_64", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "DestReg", "==", "SuperReg", ")", "return", ";", "SrcReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSHRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_128", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "DestReg", "==", "SuperReg", ")", "return", ";", "SrcReg", "=", "SuperReg", ";", "}", "unsigned", "Opc", ";", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR", ";", "else", "if", "(", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR8", ";", "else", "if", "(", "PPC", "::", "F4RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "FMR", ";", "else", "if", "(", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "MCRF", ";", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "VOR", ";", "else", "if", "(", "PPC", "::", "VSRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "XXLOR", ";", "else", "if", "(", "PPC", "::", "CRBITRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "CROR", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "getNumOperands", "(", ")", "==", "3", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::F8RCRegClass", "PPC::VSLRCRegClass", "PPC::sub_64", "PPC::VSRCRegClass", "PPC::VRRCRegClass", "PPC::VSHRCRegClass", "PPC::sub_128", "PPC::VSRCRegClass", "PPC::F8RCRegClass", "PPC::VSLRCRegClass", "PPC::sub_64", "PPC::VSRCRegClass", "PPC::VRRCRegClass", "PPC::VSHRCRegClass", "PPC::sub_128", "PPC::VSRCRegClass", "PPC::GPRCRegClass", "PPC::OR", "PPC::G8RCRegClass", "PPC::OR8", "PPC::F4RCRegClass", "PPC::FMR", "PPC::CRRCRegClass", "PPC::MCRF", "PPC::VRRCRegClass", "PPC::VOR", "PPC::VSRCRegClass", "PPC::XXLOR", "PPC::CRBITRCRegClass", "PPC::CROR", "\"Impossible reg-to-reg copy\"", "3" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "SmallPIC", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setShrinkWrapDisabled", "(", "true", ")", ";", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createVideocoreELFObjectWriter", "(", "OS", ",", "OSType", ",", "true", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "Videocore", "Videocore" ]

[]

[ "<s>", "static", "bool", "prologue_saved_reg_p", "(", "unsigned", "regno", ")", "{", "gcc_assert", "(", "GP_REG_P", "(", "regno", ")", ")", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "true", ";", "if", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "true", ";", "if", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "regno", "==", "RA_REGNO", "&&", "df_regs_ever_live_p", "(", "RA_REGNO", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "should", "be", "saved", "in", "the", "prologue", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "reg_class_t", "nios2_preferred_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "regclass", ")", "{", "return", "regclass", "==", "NO_REGS", "?", "GENERAL_REGS", ":", "regclass", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_RELOAD_CLASS", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "void", "init_device", "(", ")", "{", "init_hsa_runtime_functions", "(", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_init_fn", "(", ")", ",", "\"Initialize run-time\"", ")", ";", "XHSA_CMP", "(", "hsa_fns", ".", "hsa_iterate_agents_fn", "(", "get_gpu_agent", ",", "NULL", ")", ",", "status", "==", "HSA_STATUS_SUCCESS", "||", "status", "==", "HSA_STATUS_INFO_BREAK", ",", "\"Find a device\"", ")", ";", "uint32_t", "queue_size", "=", "0", ";", "XHSA", "(", "hsa_fns", ".", "hsa_agent_get_info_fn", "(", "device", ",", "HSA_AGENT_INFO_QUEUE_MAX_SIZE", ",", "&", "queue_size", ")", ",", "\"Find max queue size\"", ")", ";", "XHSA", "(", "hsa_fns", ".", "hsa_queue_create_fn", "(", "device", ",", "queue_size", ",", "HSA_QUEUE_TYPE_SINGLE", ",", "NULL", ",", "NULL", ",", "UINT32_MAX", ",", "UINT32_MAX", ",", "&", "queue", ")", ",", "\"Set up a device queue\"", ")", ";", "XHSA_CMP", "(", "hsa_fns", ".", "hsa_agent_iterate_regions_fn", "(", "device", ",", "get_kernarg_region", ",", "NULL", ")", ",", "status", "==", "HSA_STATUS_SUCCESS", "||", "status", "==", "HSA_STATUS_INFO_BREAK", ",", "\"Locate kernargs memory\"", ")", ";", "XHSA_CMP", "(", "hsa_fns", ".", "hsa_agent_iterate_regions_fn", "(", "device", ",", "get_heap_region", ",", "NULL", ")", ",", "status", "==", "HSA_STATUS_SUCCESS", "||", "status", "==", "HSA_STATUS_INFO_BREAK", ",", "\"Locate device memory\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "HSA", "Runtime", "library", "and", "GPU", "device", "." ]

[ "gcn", "\"Initialize run-time\"", "\"Find a device\"", "0", "\"Find max queue size\"", "\"Set up a device queue\"", "\"Locate kernargs memory\"", "\"Locate device memory\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_RegMask", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "assert", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "\"Altivec is not implemented on AIX yet.\"", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "CSR_AIX64_RegMask", ":", "CSR_AIX32_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR32_ColdCC_SPE_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_RegMask", ":", "CSR_SVR464_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR432_SPE_RegMask", ":", "CSR_SVR432_RegMask", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "\"Altivec is not implemented on AIX yet.\"", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Checking if value is in small-data, -G\"", "<<", "SmallDataThreshold", "<<", "\": \\\"\"", "<<", "GV", "->", "getName", "(", ")", "<<", "\"\\\": \"", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVar", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, not a global variable\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "GVar", "->", "hasSection", "(", ")", ")", "{", "bool", "IsSmall", "=", "isSmallDataSection", "(", "GVar", "->", "getSection", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "(", "IsSmall", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\", has section: \"", "<<", "GVar", "->", "getSection", "(", ")", "<<", "'\\n'", ")", ";", "return", "IsSmall", ";", "}", "if", "(", "GVar", "->", "isConstant", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is a constant\\n\"", ")", ";", "return", "false", ";", "}", "bool", "IsLocal", "=", "GVar", "->", "hasLocalLinkage", "(", ")", ";", "if", "(", "!", "StaticsInSData", "&&", "IsLocal", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is static\\n\"", ")", ";", "return", "false", ";", "}", "Type", "*", "GType", "=", "GVar", "->", "getType", "(", ")", ";", "if", "(", "PointerType", "*", "PT", "=", "dyn_cast", "<", "PointerType", ">", "(", "GType", ")", ")", "GType", "=", "PT", "->", "getElementType", "(", ")", ";", "if", "(", "isa", "<", "ArrayType", ">", "(", "GType", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is an array\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "StructType", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "GType", ")", ")", "{", "if", "(", "ST", "->", "isOpaque", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has opaque type\\n\"", ")", ";", "return", "false", ";", "}", "}", "unsigned", "Size", "=", "GVar", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GType", ")", ";", "if", "(", "Size", "==", "0", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has size 0\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "Size", ">", "SmallDataThreshold", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, size exceeds sdata threshold: \"", "<<", "Size", "<<", "'\\n'", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"yes\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon", "\"Checking if value is in small-data, -G\"", "\": \\\"\"", "\"\\\": \"", "\"no, not a global variable\\n\"", "\"yes\"", "\"no\"", "\", has section: \"", "\"no, is a constant\\n\"", "\"no, is static\\n\"", "\"no, is an array\\n\"", "\"no, has opaque type\\n\"", "0", "\"no, has size 0\\n\"", "\"no, size exceeds sdata threshold: \"", "\"yes\\n\"" ]

[]

[ "<s>", "static", "bool", "rs6000_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ")", "{", "bool", "reg_offset_p", "=", "reg_offset_addressing_ok_p", "(", "mode", ")", ";", "if", "(", "VECTOR_MEM_ALTIVEC_P", "(", "mode", ")", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "16", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "TARGET_ELF", "&&", "RS6000_SYMBOL_REF_TLS_P", "(", "x", ")", ")", "return", "0", ";", "if", "(", "legitimate_indirect_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "GET_CODE", "(", "x", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "&&", "mode_supports_pre_incdec_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "virtual_stack_registers_memory_p", "(", "x", ")", ")", "return", "1", ";", "if", "(", "reg_offset_p", "&&", "legitimate_small_data_p", "(", "mode", ",", "x", ")", ")", "return", "1", ";", "if", "(", "reg_offset_p", "&&", "legitimate_constant_pool_address_p", "(", "x", ",", "mode", ",", "reg_ok_strict", "||", "lra_in_progress", ")", ")", "return", "1", ";", "if", "(", "mode", "==", "TImode", "&&", "TARGET_QUAD_MEMORY", "&&", "TARGET_VSX_TIMODE", ")", "return", "0", ";", "if", "(", "!", "reg_ok_strict", "&&", "reg_offset_p", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "(", "XEXP", "(", "x", ",", "0", ")", "==", "virtual_stack_vars_rtx", "||", "XEXP", "(", "x", ",", "0", ")", "==", "arg_pointer_rtx", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "return", "1", ";", "if", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ",", "false", ")", ")", "return", "1", ";", "if", "(", "mode", "!=", "TFmode", "&&", "mode", "!=", "TDmode", "&&", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "TARGET_DOUBLE_FLOAT", ")", "||", "TARGET_POWERPC64", "||", "(", "mode", "!=", "DFmode", "&&", "mode", "!=", "DDmode", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "mode", "!=", "DDmode", ")", ")", "&&", "(", "TARGET_POWERPC64", "||", "mode", "!=", "DImode", ")", "&&", "(", "mode", "!=", "TImode", "||", "VECTOR_MEM_VSX_P", "(", "TImode", ")", ")", "&&", "mode", "!=", "PTImode", "&&", "!", "avoiding_indexed_address_p", "(", "mode", ")", "&&", "legitimate_indexed_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "TARGET_UPDATE", "&&", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", "&&", "mode_supports_pre_modify_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_ok_strict", ")", "&&", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "reg_ok_strict", ",", "false", ")", "||", "(", "!", "avoiding_indexed_address_p", "(", "mode", ")", "&&", "legitimate_indexed_address_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "reg_ok_strict", ")", ")", ")", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "return", "1", ";", "if", "(", "reg_offset_p", "&&", "legitimate_lo_sum_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "TARGET_LEGITIMATE_ADDRESS_P", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "On", "the", "RS/6000", ",", "there", "are", "four", "valid", "address", ":", "a", "SYMBOL_REF", "that", "refers", "to", "a", "constant", "pool", "entry", "of", "an", "address", "(", "or", "the", "sum", "of", "it", "plus", "a", "constant", ")", ",", "a", "short", "(", "16-bit", "signed", ")", "constant", "plus", "a", "register", ",", "the", "sum", "of", "two", "registers", ",", "or", "a", "register", "indirect", ",", "possibly", "with", "an", "auto-increment", ".", "For", "DFmode", ",", "DDmode", "and", "DImode", "with", "a", "constant", "plus", "register", ",", "we", "must", "ensure", "that", "both", "words", "are", "addressable", "or", "PowerPC64", "with", "offset", "word", "aligned", ".", "For", "modes", "spanning", "multiple", "registers", "(", "DFmode", "and", "DDmode", "in", "32-bit", "GPRs", ",", "32-bit", "DImode", ",", "TImode", ",", "TFmode", ",", "TDmode", ")", ",", "indexed", "addressing", "can", "not", "be", "used", "because", "adjacent", "memory", "cells", "are", "accessed", "by", "adding", "word-sized", "offsets", "during", "assembly", "output", "." ]

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

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "for", "(", "const", "SDep", "&", "PI", ":", "SU", "->", "Preds", ")", "{", "unsigned", "PredReadyCycle", "=", "PI", ".", "getSUnit", "(", ")", "->", "TopReadyCycle", ";", "unsigned", "MinLatency", "=", "PI", ".", "getLatency", "(", ")", ";", "Top", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Top", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "TopReadyCycle", "<", "PredReadyCycle", "+", "MinLatency", ")", "SU", "->", "TopReadyCycle", "=", "PredReadyCycle", "+", "MinLatency", ";", "}", "if", "(", "!", "SU", "->", "isScheduled", ")", "Top", ".", "releaseNode", "(", "SU", ",", "SU", "->", "TopReadyCycle", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "requiresUniformRegister", "(", "MachineFunction", "&", "MF", ",", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "{", "const", "SIRegisterInfo", "*", "SIRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "ImmutableCallSite", "CS", "(", "CI", ")", ";", "TargetLowering", "::", "AsmOperandInfoVector", "TargetConstraints", "=", "ParseConstraints", "(", "MF", ".", "getDataLayout", "(", ")", ",", "Subtarget", "->", "getRegisterInfo", "(", ")", ",", "CS", ")", ";", "for", "(", "auto", "&", "TC", ":", "TargetConstraints", ")", "{", "if", "(", "TC", ".", "Type", "==", "InlineAsm", "::", "isOutput", ")", "{", "ComputeConstraintToUse", "(", "TC", ",", "SDValue", "(", ")", ")", ";", "unsigned", "AssignedReg", ";", "const", "TargetRegisterClass", "*", "RC", ";", "std", "::", "tie", "(", "AssignedReg", ",", "RC", ")", "=", "getRegForInlineAsmConstraint", "(", "SIRI", ",", "TC", ".", "ConstraintCode", ",", "TC", ".", "ConstraintVT", ")", ";", "if", "(", "RC", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "AssignedReg", "!=", "0", "&&", "SIRI", "->", "isSGPRReg", "(", "MRI", ",", "AssignedReg", ")", ")", "return", "true", ";", "else", "if", "(", "SIRI", "->", "isSGPRClass", "(", "RC", ")", ")", "return", "true", ";", "}", "}", "}", "}", "}", "SmallPtrSet", "<", "const", "Value", "*", ",", "16", ">", "Visited", ";", "return", "hasCFUser", "(", "V", ",", "Visited", ",", "Subtarget", "->", "getWavefrontSize", "(", ")", ")", ";", "}", "</s>" ]

[ "Allows", "target", "to", "decide", "about", "the", "register", "class", "of", "the", "specific", "value", "that", "is", "live", "outside", "the", "defining", "block", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "0", "SI", "SI", "16" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "MSP430::PUSH16r" ]

[]

[ "<s>", "static", "void", "emit_store_conditional", "(", "enum", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_store_conditional_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_store_conditional_di", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "m68k_init_cc", "(", ")", "{", "flags_compare_op0", "=", "flags_compare_op1", "=", "NULL_RTX", ";", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "flags_valid", "=", "FLAGS_VALID_NO", ";", "}", "</s>" ]

[ "Called", "through", "CC_STATUS_INIT", ",", "which", "is", "invoked", "by", "final", "whenever", "a", "label", "is", "encountered", "." ]

[ "m68k" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "AArch64AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "!", "TheTriple", ".", "isOSBinFormatELF", "(", ")", ")", "return", "None", ";", "unsigned", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_AARCH64_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_AARCH64_ABS16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_AARCH64_ABS32", ")", ".", "Case", "(", "\"BFD_RELOC_64\"", ",", "ELF", "::", "R_AARCH64_ABS64", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"BFD_RELOC_NONE\"", "\"BFD_RELOC_16\"", "\"BFD_RELOC_32\"", "\"BFD_RELOC_64\"", "1u", "1u" ]

[]

[ "<s>", "static", "void", "avr_asm_out_dtor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "fputs", "(", "\"\\t.global __do_global_dtors\\n\"", ",", "asm_out_file", ")", ";", "default_dtor_section_asm_out_destructor", "(", "symbol", ",", "priority", ")", ";", "}", "</s>" ]

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

[ "avr", "\"\\t.global __do_global_dtors\\n\"" ]

[]

[ "<s>", "static", "void", "core2i7_first_cycle_multipass_issue", "(", "void", "*", "_data", ",", "signed", "char", "*", "ready_try", ",", "int", "n_ready", ",", "rtx_insn", "*", "insn", ",", "const", "void", "*", "_prev_data", ")", "{", "ix86_first_cycle_multipass_data_t", "data", "=", "(", "ix86_first_cycle_multipass_data_t", ")", "_data", ";", "const_ix86_first_cycle_multipass_data_t", "prev_data", "=", "(", "const_ix86_first_cycle_multipass_data_t", ")", "_prev_data", ";", "int", "insn_size", "=", "ix86_min_insn_size", "(", "insn", ")", ";", "data", "->", "ifetch_block_len", "=", "prev_data", "->", "ifetch_block_len", "+", "insn_size", ";", "data", "->", "ifetch_block_n_insns", "=", "prev_data", "->", "ifetch_block_n_insns", "+", "1", ";", "gcc_assert", "(", "data", "->", "ifetch_block_len", "<=", "core2i7_ifetch_block_size", "&&", "data", "->", "ifetch_block_n_insns", "<=", "core2i7_ifetch_block_max_insns", ")", ";", "if", "(", "!", "data", "->", "ready_try_change", ")", "{", "data", "->", "ready_try_change", "=", "sbitmap_alloc", "(", "n_ready", ")", ";", "data", "->", "ready_try_change_size", "=", "n_ready", ";", "}", "else", "if", "(", "data", "->", "ready_try_change_size", "<", "n_ready", ")", "{", "data", "->", "ready_try_change", "=", "sbitmap_resize", "(", "data", "->", "ready_try_change", ",", "n_ready", ",", "0", ")", ";", "data", "->", "ready_try_change_size", "=", "n_ready", ";", "}", "bitmap_clear", "(", "data", "->", "ready_try_change", ")", ";", "core2i7_first_cycle_multipass_filter_ready_try", "(", "data", ",", "ready_try", ",", "n_ready", ",", "false", ")", ";", "}", "</s>" ]

[ "INSN", "is", "being", "issued", "in", "current", "solution", ".", "Account", "for", "its", "impact", "on", "the", "decoder", "model", "." ]

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

[]

[ "<s>", "void", "X86AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "FeatureFlagsAnd", "=", "0", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_IBT", ";", "if", "(", "M", ".", "getModuleFlag", "(", "\"cf-protection-return\"", ")", ")", "FeatureFlagsAnd", "|=", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_SHSTK", ";", "if", "(", "FeatureFlagsAnd", ")", "{", "if", "(", "!", "TT", ".", "isArch32Bit", "(", ")", "&&", "!", "TT", ".", "isArch64Bit", "(", ")", ")", "llvm_unreachable", "(", "\"CFProtection used on invalid architecture!\"", ")", ";", "MCSection", "*", "Cur", "=", "OutStreamer", "->", "getCurrentSectionOnly", "(", ")", ";", "MCSection", "*", "Nt", "=", "MMI", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".note.gnu.property\"", ",", "ELF", "::", "SHT_NOTE", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Nt", ")", ";", "const", "int", "WordSize", "=", "TT", ".", "isArch64Bit", "(", ")", "&&", "!", "TT", ".", "isX32", "(", ")", "?", "8", ":", "4", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "8", "+", "WordSize", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "NT_GNU_PROPERTY_TYPE_0", ",", "4", ")", ";", "OutStreamer", "->", "emitBytes", "(", "StringRef", "(", "\"GNU\"", ",", "4", ")", ")", ";", "OutStreamer", "->", "emitInt32", "(", "ELF", "::", "GNU_PROPERTY_X86_FEATURE_1_AND", ")", ";", "OutStreamer", "->", "emitInt32", "(", "4", ")", ";", "OutStreamer", "->", "emitInt32", "(", "FeatureFlagsAnd", ")", ";", "emitAlignment", "(", "WordSize", "==", "4", "?", "Align", "(", "4", ")", ":", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "endSection", "(", "Nt", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Cur", ")", ";", "}", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "StringRef", "(", "\"@feat.00\"", ")", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "S", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_NULL", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "int64_t", "Feat00Flags", "=", "0", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", ")", "{", "Feat00Flags", "|=", "1", ";", "}", "if", "(", "M", ".", "getModuleFlag", "(", "\"cfguard\"", ")", ")", "{", "Feat00Flags", "|=", "0x800", ";", "}", "if", "(", "M", ".", "getModuleFlag", "(", "\"ehcontguard\"", ")", ")", "{", "Feat00Flags", "|=", "0x4000", ";", "}", "OutStreamer", "->", "emitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "S", ",", "MCConstantExpr", "::", "create", "(", "Feat00Flags", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "}", "OutStreamer", "->", "emitSyntaxDirective", "(", ")", ";", "bool", "is16", "=", "TT", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ";", "if", "(", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", "&&", "is16", ")", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"cf-protection-branch\"", "X86", "\"cf-protection-return\"", "X86", "\"CFProtection used on invalid architecture!\"", "\".note.gnu.property\"", "8", "4", "4", "4", "8", "4", "4", "8", "4", "4", "\"GNU\"", "4", "X86", "4", "4", "4", "8", "\"@feat.00\"", "0", "1", "\"cfguard\"", "0x800", "\"ehcontguard\"", "0x4000" ]

[]

[ "<s>", "const", "MCExpr", "*", "JVMAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "return", "AsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "unsigned", "int", "increase_distance", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "next", ",", "unsigned", "int", "distance", ")", "{", "df_ref", "def", ",", "use", ";", "if", "(", "!", "prev", "||", "!", "next", ")", "return", "distance", "+", "(", "distance", "&", "1", ")", "+", "2", ";", "if", "(", "!", "DF_INSN_USES", "(", "next", ")", "||", "!", "DF_INSN_DEFS", "(", "prev", ")", ")", "return", "distance", "+", "1", ";", "FOR_EACH_INSN_USE", "(", "use", ",", "next", ")", "FOR_EACH_INSN_DEF", "(", "def", ",", "prev", ")", "if", "(", "!", "DF_REF_IS_ARTIFICIAL", "(", "def", ")", "&&", "DF_REF_REGNO", "(", "use", ")", "==", "DF_REF_REGNO", "(", "def", ")", ")", "return", "distance", "+", "(", "distance", "&", "1", ")", "+", "2", ";", "return", "distance", "+", "1", ";", "}", "</s>" ]

[ "Increase", "given", "DISTANCE", "in", "half-cycles", "according", "to", "dependencies", "between", "PREV", "and", "NEXT", "instructions", ".", "Add", "1", "half-cycle", "if", "there", "is", "no", "dependency", "and", "go", "to", "next", "cycle", "if", "there", "is", "some", "dependecy", "." ]

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

[]

[ "<s>", "void", "MMIXInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "MMIX", "MMIX" ]

[]

[ "<s>", "const", "uint32_t", "*", "Z80RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "Is24Bit", "?", "CSR_EZ80_C_RegMask", ":", "CSR_Z80_C_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "case", "CallingConv", "::", "Z80_LibCall", ":", "case", "CallingConv", "::", "Z80_LibCall_AC", ":", "case", "CallingConv", "::", "Z80_LibCall_BC", ":", "case", "CallingConv", "::", "Z80_LibCall_C", ":", "case", "CallingConv", "::", "Z80_LibCall_L", ":", "return", "Is24Bit", "?", "CSR_EZ80_AllRegs_RegMask", ":", "CSR_Z80_AllRegs_RegMask", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unsupported calling convention\"", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80", "Z80" ]

[]

[ "<s>", "enum", "h8sx_shift_type", "h8sx_classify_shift", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "op", ")", "{", "if", "(", "!", "TARGET_H8300SX", ")", "return", "H8SX_SHIFT_NONE", ";", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", ")", "return", "H8SX_SHIFT_BINARY", ";", "if", "(", "INTVAL", "(", "op", ")", "<=", "0", "||", "INTVAL", "(", "op", ")", ">=", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "return", "H8SX_SHIFT_NONE", ";", "if", "(", "exact_log2", "(", "INTVAL", "(", "op", ")", ")", ">=", "0", ")", "return", "H8SX_SHIFT_UNARY", ";", "return", "H8SX_SHIFT_BINARY", ";", "case", "ASHIFTRT", ":", "if", "(", "op", "==", "const1_rtx", "||", "op", "==", "const2_rtx", ")", "return", "H8SX_SHIFT_UNARY", ";", "return", "H8SX_SHIFT_NONE", ";", "case", "ROTATE", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "op", ")", "==", "1", "||", "INTVAL", "(", "op", ")", "==", "2", "||", "INTVAL", "(", "op", ")", "==", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "2", "||", "INTVAL", "(", "op", ")", "==", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "1", ")", ")", "return", "H8SX_SHIFT_UNARY", ";", "return", "H8SX_SHIFT_NONE", ";", "default", ":", "return", "H8SX_SHIFT_NONE", ";", "}", "}", "</s>" ]

[ "Classify", "a", "shift", "with", "the", "given", "mode", "and", "code", ".", "OP", "is", "the", "shift", "amount", "." ]

[ "h8300", "0", "0", "1", "2", "2", "1" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "addPass", "(", "createPPCTLSDynamicCallPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "SIInstrInfo", "::", "isMUBUF", "(", "*", "MI", ")", ")", "return", "false", ";", "int64_t", "NewOffset", "=", "Offset", "+", "getMUBUFInstrOffset", "(", "MI", ")", ";", "return", "isUInt", "<", "12", ">", "(", "NewOffset", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ia64_vms_output_aligned_decl_common", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "attr", ")", "attr", "=", "lookup_attribute", "(", "\"common_object\"", ",", "attr", ")", ";", "if", "(", "attr", ")", "{", "tree", "id", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ";", "const", "char", "*", "name", ";", "if", "(", "TREE_CODE", "(", "id", ")", "==", "IDENTIFIER_NODE", ")", "name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "else", "if", "(", "TREE_CODE", "(", "id", ")", "==", "STRING_CST", ")", "name", "=", "TREE_STRING_POINTER", "(", "id", ")", ";", "else", "abort", "(", ")", ";", "fprintf", "(", "file", ",", "\"\\t.vms_common\\t\\\"%s\\\",\"", ",", "name", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"%s\"", ",", "COMMON_ASM_OP", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\",%u\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "</s>" ]

[ "Part", "of", "the", "low", "level", "implementation", "of", "DEC", "Ada", "pragma", "Common_Object", "." ]

[ "ia64", "\"common_object\"", "\"\\t.vms_common\\t\\\"%s\\\",\"", "\"%s\"", "\",\"", "\",%u\"" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "CommentStream", "=", "&", "cStream", ";", "InternalInstruction", "internalInstr", ";", "dlog_t", "loggerFn", "=", "logger", ";", "if", "(", "&", "vStream", "==", "&", "nulls", "(", ")", ")", "loggerFn", "=", "0", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "const", "void", "*", ")", "&", "region", ",", "loggerFn", ",", "(", "void", "*", ")", "&", "vStream", ",", "(", "const", "void", "*", ")", "MII", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "Fail", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "return", "(", "!", "translateInstruction", "(", "instr", ",", "internalInstr", ",", "this", ")", ")", "?", "Success", ":", "Fail", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "R600" ]

[]

[ "<s>", "static", "bool", "peek", "(", "struct", "InternalInstruction", "*", "insn", ",", "uint8_t", "&", "byte", ")", "{", "uint64_t", "offset", "=", "insn", "->", "readerCursor", "-", "insn", "->", "startLocation", ";", "if", "(", "offset", ">=", "insn", "->", "bytes", ".", "size", "(", ")", ")", "return", "true", ";", "byte", "=", "insn", "->", "bytes", "[", "offset", "]", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "current", "operation", "." ]

[ "X86" ]

[]

[ "<s>", "void", "X86WinAllocaExpander", "::", "lower", "(", "MachineInstr", "*", "MI", ",", "Lowering", "L", ")", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "int64_t", "Amount", "=", "getWinAllocaAmount", "(", "MI", ",", "MRI", ")", ";", "if", "(", "Amount", "==", "0", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "return", ";", "}", "bool", "Is64Bit", "=", "STI", "->", "is64Bit", "(", ")", ";", "assert", "(", "SlotSize", "==", "4", "||", "SlotSize", "==", "8", ")", ";", "unsigned", "RegA", "=", "(", "SlotSize", "==", "8", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "switch", "(", "L", ")", "{", "case", "TouchAndSub", ":", "assert", "(", "Amount", ">=", "SlotSize", ")", ";", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "RegA", ",", "RegState", "::", "Undef", ")", ";", "Amount", "-=", "SlotSize", ";", "if", "(", "!", "Amount", ")", "break", ";", "case", "Sub", ":", "assert", "(", "Amount", ">", "0", ")", ";", "if", "(", "Amount", "==", "SlotSize", ")", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "RegA", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "getSubOpcode", "(", "Is64Bit", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "break", ";", "case", "Probe", ":", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "RegA", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "STI", "->", "getFrameLowering", "(", ")", "->", "emitStackProbe", "(", "*", "MBB", "->", "getParent", "(", ")", ",", "*", "MBB", ",", "MI", ",", "DL", ",", "false", ")", ";", "break", ";", "}", "unsigned", "AmountReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "for", "(", ";", ";", ")", "{", "if", "(", "!", "MRI", "->", "use_empty", "(", "AmountReg", ")", ")", "break", ";", "MachineInstr", "*", "AmountDef", "=", "MRI", "->", "getUniqueVRegDef", "(", "AmountReg", ")", ";", "if", "(", "!", "AmountDef", ")", "break", ";", "if", "(", "AmountDef", "->", "isCopy", "(", ")", "&&", "AmountDef", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "AmountReg", "=", "AmountDef", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ";", "AmountDef", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "X86", "X86", "0", "4", "8", "8", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "0", "X86::PUSH64r", "X86::PUSH32r", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "tree", "alpha_fold_builtin_cmpbge", "(", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "==", "3", ")", "{", "int", "i", ",", "val", ";", "for", "(", "i", "=", "0", ",", "val", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "HOST_WIDE_INT", "c0", "=", "(", "opint", "[", "0", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "unsigned", "HOST_WIDE_INT", "c1", "=", "(", "opint", "[", "1", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "if", "(", "c0", ">=", "c1", ")", "val", "|=", "1", "<<", "i", ";", "}", "return", "build_int_cst", "(", "long_integer_type_node", ",", "val", ")", ";", "}", "else", "if", "(", "op_const", "==", "2", "&&", "opint", "[", "1", "]", "==", "0", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "0xff", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Fold", "the", "builtin", "for", "the", "CMPBGE", "instruction", ".", "This", "is", "a", "vector", "comparison", "with", "an", "8", "bit", "output", "vector", ".", "OPINT", "contains", "the", "integer", "operands", ";", "bit", "N", "of", "OP_CONST", "is", "set", "if", "OPINT", "[", "N", "]", "is", "valid", "." ]

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

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", ")", "{", "uint64_t", "ImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "ImmVal", "==", "0x100000000ULL", "||", "ImmVal", "==", "0xffffffff", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "And", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", "&&", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", "&&", "Imm", ".", "getZExtValue", "(", ")", "==", "0x80000000", ")", "return", "TTI", "::", "TCC_Free", ";", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "divideCeil", "(", "BitSize", ",", "64", ")", ";", "int", "Cost", "=", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "return", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0U", "0", "2", "0", "1", "64", "0x100000000ULL", "0xffffffff", "1", "1", "64", "32", "1", "1", "64", "0x80000000", "1", "1", "1", "64", "X86", "X86" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"mproc DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "mproc", "\"mproc DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "pru_option_override", "(", "void", ")", "{", "SUBTARGET_OVERRIDE_OPTIONS", ";", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"%<-fpic%> is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"%<-fPIC%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"%<-fpie%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"%<-fPIE%> is not supported\"", ")", ";", "if", "(", "flag_reorder_blocks_and_partition", ")", "{", "inform", "(", "input_location", ",", "\"%<-freorder-blocks-and-partition%> \"", "\"not supported on this architecture\"", ")", ";", "flag_reorder_blocks_and_partition", "=", "0", ";", "flag_reorder_blocks", "=", "1", ";", "}", "init_machine_status", "=", "&", "pru_init_machine_status", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "pru_register_abicheck_pass", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "pru", "1", "\"%<-fpic%> is not supported\"", "2", "\"%<-fPIC%> is not supported\"", "1", "\"%<-fpie%> is not supported\"", "2", "\"%<-fPIE%> is not supported\"", "\"%<-freorder-blocks-and-partition%> \"", "\"not supported on this architecture\"", "0", "1" ]

[]

[ "<s>", "int", "Z80oldInstrInfo", "::", "getSPAdjust", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Z80old", "::", "POP16r", ":", "case", "Z80old", "::", "POP16AF", ":", "return", "2", ";", "case", "Z80old", "::", "PUSH16r", ":", "case", "Z80old", "::", "PUSH16AF", ":", "return", "-", "2", ";", "}", "return", "TargetInstrInfo", "::", "getSPAdjust", "(", "MI", ")", ";", "}", "</s>" ]

[ "getSPAdjust", "-", "This", "returns", "the", "stack", "pointer", "adjustment", "made", "by", "this", "instruction", "." ]

[ "Z80old", "Z80old", "Z80old::POP16r", "Z80old::POP16AF", "2", "Z80old::PUSH16r", "Z80old::PUSH16AF", "2" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "PowerPC", "PPC", "PPC::STD", "PPC::STW", "PPC::STFS", "PPC::STFD", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "void", "Initialize", "(", "const", "MachineFunction", "&", "MF", ",", "bool", "isPIC", ",", "bool", "isLittleEndian", ")", "{", "IsPIC", "=", "isPIC", ";", "IsLittleEndian", "=", "isLittleEndian", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "FS", "=", "Key", ".", "substr", "(", "CPU", ".", "size", "(", ")", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "X86GISelActualAccessor", "*", "GISel", "=", "new", "X86GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "I", ",", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "*", "this", ",", "*", "I", ",", "*", "RBI", ")", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Register", "(", "ARM", "::", "SP", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s32", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildPtrAdd", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

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

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "0", "32", "32", "ARM::SP" ]

[]

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

[ "Return", "true", "if", "this", "asm", "streamer", "supports", "emitting", "unformatted", "text", "to", "the", ".s", "file", "with", "EmitRawText", "." ]

[ "PTX" ]

[]