Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "ARMOperand", "*", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "const", "MCConstantExpr", "*", "OffsetImm", ",", "unsigned", "OffsetRegNum", ",", "ARM_AM", "::", "ShiftOpc", "ShiftType", ",", "unsigned", "ShiftImm", ",", "unsigned", "Alignment", ",", "bool", "isNegative", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "k_Memory", ")", ";", "Op", "->", "Memory", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Memory", ".", "OffsetImm", "=", "OffsetImm", ";", "Op", "->", "Memory", ".", "OffsetRegNum", "=", "OffsetRegNum", ";", "Op", "->", "Memory", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Memory", ".", "ShiftImm", "=", "ShiftImm", ";", "Op", "->", "Memory", ".", "Alignment", "=", "Alignment", ";", "Op", "->", "Memory", ".", "isNegative", "=", "isNegative", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "ARM", "ARM", "ARM_AM::ShiftOpc", "ARM", "ARM" ]

[]

[ "<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "char", "*", "specfile_name", ";", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "0", "==", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "0", "!=", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "specfile_name", "=", "concat", "(", "argv", "[", "0", "]", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "NULL", ")", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"'%s': mmcu='%s'\\n'%s': specfile='%s'\\n\\n\"", ",", "__FUNCTION__", ",", "mmcu", ",", "__FUNCTION__", ",", "specfile_name", ")", ";", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "if", "(", "(", "0", "==", "strncmp", "(", "mmcu", ",", "\"avr\"", ",", "strlen", "(", "\"avr\"", ")", ")", "&&", "specfile_name", "[", "0", "]", "==", "'.'", ")", "||", "(", "IS_ABSOLUTE_PATH", "(", "specfile_name", ")", "&&", "!", "access", "(", "specfile_name", ",", "R_OK", ")", ")", ")", "{", "return", "concat", "(", "\"-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s\"", ",", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "return", "avr_diagnose_devicespecs_error", "(", "mmcu", ",", "specfile_name", ")", ";", "}", "</s>" ]

[ "Implement", "spec", "function", "`", "device-specs-file麓", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "." ]

[ "avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "0", "\"device-specs\"", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "0", "\"specs-\"", "\"'%s': mmcu='%s'\\n'%s': specfile='%s'\\n\\n\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "0", "\"avr\"", "\"avr\"", "0", "\"-specs=device-specs\"", "\"specs-\"", "\"%s\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \"" ]

[]

[ "<s>", "static", "int", "mcore_and_cost", "(", "rtx", "x", ")", "{", "int", "val", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "2", ";", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "CONST_OK_FOR_K", "(", "val", ")", "||", "CONST_OK_FOR_M", "(", "~", "val", ")", ")", "return", "2", ";", "else", "if", "(", "const_ok_for_mcore", "(", "val", ")", ")", "return", "3", ";", "else", "if", "(", "TARGET_HARDLIT", "&&", "mcore_const_ok_for_inline", "(", "val", ")", ")", "return", "4", ";", "return", "5", ";", "}", "</s>" ]

[ "What", "does", "an", "and", "instruction", "cost", "-", "we", "do", "this", "b/c", "immediates", "may", "have", "been", "relaxed", ".", "We", "want", "to", "ensure", "that", "cse", "will", "cse", "relaxed", "immeds", "out", ".", "Otherwise", "we", "'ll", "get", "bad", "code", "(", "multiple", "reloads", "of", "the", "same", "const", ")", "." ]

[ "mcore", "1", "2", "1", "2", "3", "4", "5" ]

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "Function", "*", ">", "FuncsToClone", ";", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Function", "&", "F", "=", "*", "I", ";", "if", "(", "!", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "FuncsToClone", ".", "push_back", "(", "&", "F", ")", ";", "}", "for", "(", "Function", "*", "F", ":", "FuncsToClone", ")", "{", "ValueToValueMapTy", "VMap", ";", "Function", "*", "NewFunc", "=", "CloneFunction", "(", "F", ",", "VMap", ",", "false", ")", ";", "NewFunc", "->", "setLinkage", "(", "GlobalValue", "::", "InternalLinkage", ")", ";", "F", "->", "getParent", "(", ")", "->", "getFunctionList", "(", ")", ".", "push_back", "(", "NewFunc", ")", ";", "F", "->", "replaceAllUsesWith", "(", "NewFunc", ")", ";", "}", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Function", "&", "F", "=", "*", "I", ";", "if", "(", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "{", "F", ".", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"### runOnMachineFunction\\n\"", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "Comet2Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Comet2", "\"### runOnMachineFunction\\n\"", "Comet2" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_ternop_insn", "(", "bool", "vd_accum_p", ",", "insn_code", "icode", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "builtin_types", "[", "type", ".", "index", "]", ".", "vector", ")", ";", "int", "arg_offset", "=", "0", ";", "if", "(", "use_real_mask_p", "(", "pred", ")", ")", "add_input_operand", "(", "arg_offset", "++", ")", ";", "else", "add_all_one_mask_operand", "(", "mask_mode", "(", ")", ")", ";", "rtx", "vd", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "arg_offset", "++", ")", ")", ";", "rtx", "vs1", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "arg_offset", "++", ")", ")", ";", "rtx", "vs2", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "arg_offset", "++", ")", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "GET_MODE", "(", "vs1", ")", ")", ")", "{", "if", "(", "!", "vd_accum_p", ")", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "add_input_operand", "(", "mode", ",", "vs1", ")", ";", "add_input_operand", "(", "mode", ",", "vs2", ")", ";", "if", "(", "vd_accum_p", ")", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "}", "else", "{", "add_input_operand", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "vs1", ")", ";", "if", "(", "vd_accum_p", ")", "{", "add_input_operand", "(", "mode", ",", "vs2", ")", ";", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "}", "else", "{", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "add_input_operand", "(", "mode", ",", "vs2", ")", ";", "}", "add_input_operand", "(", "mode", ",", "vd", ")", ";", "}", "for", "(", "int", "argno", "=", "arg_offset", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "add_input_operand", "(", "argno", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_tail_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_mask_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_avl_type_rtx", "(", "avl_type", "::", "NONVLMAX", ")", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "with", "a", "1:1", "mapping", "between", "arguments", "and", "input", "operands", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "function_sym_iterator", "HSACodeObject", "::", "functions_begin", "(", ")", "const", "{", "auto", "TextIdxOr", "=", "getTextSectionIdx", "(", ")", ";", "if", "(", "!", "TextIdxOr", ")", "return", "functions_end", "(", ")", ";", "auto", "TextIdx", "=", "TextIdxOr", ".", "get", "(", ")", ";", "return", "function_sym_iterator", "(", "symbol_begin", "(", ")", ",", "symbol_end", "(", ")", ",", "[", "this", ",", "TextIdx", "]", "(", "const", "SymbolRef", "&", "Sym", ")", "->", "bool", "{", "auto", "ExpectedFunction", "=", "FunctionSym", "::", "asFunctionSym", "(", "getSymbol", "(", "Sym", ".", "getRawDataRefImpl", "(", ")", ")", ")", ";", "if", "(", "!", "ExpectedFunction", ")", "{", "consumeError", "(", "ExpectedFunction", ".", "takeError", "(", ")", ")", ";", "return", "false", ";", "}", "auto", "Function", "=", "ExpectedFunction", ".", "get", "(", ")", ";", "if", "(", "Function", "->", "st_shndx", "!=", "TextIdx", ")", "return", "false", ";", "return", "true", ";", "}", ")", ";", "}", "</s>" ]

[ "Begin", "iterator", "for", "functions", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "2", "&&", "\"All AArch64 cmps should have 2 operands\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "auto", "NormalizeCmpValue", "=", "[", "]", "(", "int64_t", "Value", ")", "->", "int", "{", "if", "(", "Value", "==", "0", "||", "Value", "==", "1", ")", "return", "Value", ";", "return", "2", ";", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "PTEST_PP", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWrr", ":", "case", "AArch64", "::", "SUBSWrs", ":", "case", "AArch64", "::", "SUBSWrx", ":", "case", "AArch64", "::", "SUBSXrr", ":", "case", "AArch64", "::", "SUBSXrs", ":", "case", "AArch64", "::", "SUBSXrx", ":", "case", "AArch64", "::", "ADDSWrr", ":", "case", "AArch64", "::", "ADDSWrs", ":", "case", "AArch64", "::", "ADDSWrx", ":", "case", "AArch64", "::", "ADDSXrr", ":", "case", "AArch64", "::", "ADDSXrs", ":", "case", "AArch64", "::", "ADDSXrx", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "case", "AArch64", "::", "ADDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "NormalizeCmpValue", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ")", ";", "return", "true", ";", "case", "AArch64", "::", "ANDSWri", ":", "case", "AArch64", "::", "ANDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "NormalizeCmpValue", "(", "AArch64_AM", "::", "decodeLogicalImmediate", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ANDSWri", "?", "32", ":", "64", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "AArch64", "AArch64", "2", "\"All AArch64 cmps should have 2 operands\"", "1", "0", "1", "2", "AArch64::PTEST_PP", "0", "1", "0", "0", "AArch64::SUBSWrr", "AArch64::SUBSWrs", "AArch64::SUBSWrx", "AArch64::SUBSXrr", "AArch64::SUBSXrs", "AArch64::SUBSXrx", "AArch64::ADDSWrr", "AArch64::ADDSWrs", "AArch64::ADDSWrx", "AArch64::ADDSXrr", "AArch64::ADDSXrs", "AArch64::ADDSXrx", "1", "2", "0", "0", "AArch64::SUBSWri", "AArch64::ADDSWri", "AArch64::SUBSXri", "AArch64::ADDSXri", "1", "0", "0", "2", "AArch64::ANDSWri", "AArch64::ANDSXri", "1", "0", "0", "AArch64_AM::decodeLogicalImmediate", "2", "AArch64::ANDSWri", "32", "64" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "Func", "=", "&", "F", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "return", "ProcessFunction", "(", ")", ";", "}", "</s>" ]

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

[ "JVM" ]

[]

[ "<s>", "void", "MBlazeFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "const", "MBlazeInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MBlazeInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "llvm", "::", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "bool", "requiresRA", "=", "CallConv", "==", "llvm", "::", "CallingConv", "::", "MBLAZE_INTR", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "FPOffset", ")", ";", "}", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "||", "requiresRA", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R15", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "RAOffset", ")", ";", "}", "int", "StackSize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDIK", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze::ADD", "MBlaze::R1", "MBlaze::R19", "MBlaze::R0", "MBlaze::LWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::LWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::ADDIK", "MBlaze::R1", "MBlaze::R1" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ";", "LLT", "SType", "=", "LLT", "::", "scalar", "(", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ";", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "STI", ".", "getRegisterInfo", "(", ")", "->", "getStackRegister", "(", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "SType", ")", ";", "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", "." ]

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

[]

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

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

[ "RV16K", "\"RV16K Assembly Printer\"" ]

[]

[ "<s>", "bool", "AArch64Subtarget", "::", "supportsAddressTopByteIgnored", "(", ")", "const", "{", "if", "(", "!", "UseAddressTopByteIgnored", ")", "return", "false", ";", "if", "(", "TargetTriple", ".", "isiOS", "(", ")", ")", "{", "return", "TargetTriple", ".", "getiOSVersion", "(", ")", ">=", "VersionTuple", "(", "8", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "CPU", "has", "TBI", "(", "top", "byte", "of", "addresses", "is", "ignored", "during", "HW", "address", "translation", ")", "and", "OS", "enables", "it", "." ]

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

[]

[ "<s>", "void", "aarch64_emit_sve_pred_move", "(", "rtx", "dest", ",", "rtx", "pred", ",", "rtx", "src", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "dest", ")", ",", "gen_rtvec", "(", "2", ",", "pred", ",", "src", ")", ",", "UNSPEC_MERGE_PTRUE", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "SVE", "predicated", "move", "from", "SRC", "to", "DEST", ".", "PRED", "is", "a", "predicate", "that", "is", "known", "to", "contain", "PTRUE", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "void", "Cpu0TargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "||", "!", "GlobalOrExternal", ")", "{", "unsigned", "T9Reg", "=", "Cpu0", "::", "T9", ";", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "T9Reg", ",", "Callee", ")", ")", ";", "}", "else", "Ops", ".", "push_back", "(", "Callee", ")", ";", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", ")", "{", "unsigned", "GPReg", "=", "Cpu0", "::", "GP", ";", "EVT", "Ty", "=", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Cpu0", "Cpu0", "Cpu0::T9", "Cpu0::GP", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"" ]

[]

[ "<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "Sparc" ]

[]

[ "<s>", "static", "bool", "pdp11_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "pdp11" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnSCC", "(", "CallGraphSCC", "&", "SCC", ")", "{", "Module", "&", "M", "=", "SCC", ".", "getCallGraph", "(", ")", ".", "getModule", "(", ")", ";", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "CallGraphNode", "*", "I", ":", "SCC", ")", "{", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "F", "->", "isDeclaration", "(", ")", ")", "continue", ";", "Changed", "|=", "addFeatureAttributes", "(", "*", "F", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnSCC", "-", "This", "method", "should", "be", "implemented", "by", "the", "subclass", "to", "perform", "whatever", "action", "is", "necessary", "for", "the", "specified", "SCC", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "MCSection", "*", "getExplicitSectionGlobal", "(", "const", "GlobalValue", "*", "GV", ",", "SectionKind", "Kind", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ")", "const", "override", "{", "return", "DataSection", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "HSAIL" ]

[]

[ "<s>", "const", "MachineBasicBlock", "*", "getMBB", "(", ")", "const", "{", "return", "MBB", ";", "}", "</s>" ]

[ "Return", "a", "reference", "to", "the", "basic", "block", "containing", "this", "bundle", "." ]

[ "CSKY" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "ARMCC", "::", "CondCodes", "CC", "=", "(", "ARMCC", "::", "CondCodes", ")", "(", "int", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "CC", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "0", "ARMCC::getOppositeCondition" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "TheModule", "=", "&", "M", ";", "FrameEscape", "=", "Intrinsic", "::", "getDeclaration", "(", "TheModule", ",", "Intrinsic", "::", "localescape", ")", ";", "FrameRecover", "=", "Intrinsic", "::", "getDeclaration", "(", "TheModule", ",", "Intrinsic", "::", "localrecover", ")", ";", "FrameAddress", "=", "Intrinsic", "::", "getDeclaration", "(", "TheModule", ",", "Intrinsic", "::", "frameaddress", ")", ";", "RestoreFrame", "=", "Intrinsic", "::", "getDeclaration", "(", "TheModule", ",", "Intrinsic", "::", "x86_seh_restoreframe", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "Intrinsic::getDeclaration", "Intrinsic::localescape", "Intrinsic::getDeclaration", "Intrinsic::localrecover", "Intrinsic::getDeclaration", "Intrinsic::frameaddress", "Intrinsic::getDeclaration", "Intrinsic::x86_seh_restoreframe" ]

[]

[ "<s>", "int", "visium_interrupt_function_p", "(", "void", ")", "{", "return", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "current", "function", "is", "an", "interrupt", "function", "." ]

[ "visium", "\"interrupt\"" ]

[]

[ "<s>", "bool", "intersects", "(", "const", "RegisterSet", "&", "Rs", ")", "const", "{", "return", "Bits", ".", "anyCommon", "(", "Rs", ".", "Bits", ")", ";", "}", "</s>" ]

[ "Checks", "whether", "intervals", "intersect", "." ]

[ "Hexagon" ]

[]

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

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

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

[]

[ "<s>", "void", "mips_expand_epilogue", "(", "int", "sibcall_p", ")", "{", "HOST_WIDE_INT", "step1", ",", "step2", ";", "rtx", "base", ",", "target", ";", "if", "(", "!", "sibcall_p", "&&", "mips_can_use_return_insn", "(", ")", ")", "{", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "return", ";", "}", "step1", "=", "cfun", "->", "machine", "->", "frame", ".", "total_size", ";", "step2", "=", "0", ";", "if", "(", "!", "frame_pointer_needed", ")", "base", "=", "stack_pointer_rtx", ";", "else", "{", "base", "=", "hard_frame_pointer_rtx", ";", "if", "(", "TARGET_MIPS16", ")", "step1", "-=", "cfun", "->", "machine", "->", "frame", ".", "args_size", ";", "}", "if", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", "|", "cfun", "->", "machine", "->", "frame", ".", "fmask", ")", "!=", "0", ")", "{", "step2", "=", "MIN", "(", "step1", ",", "MIPS_MAX_FIRST_STACK_STEP", ")", ";", "step1", "-=", "step2", ";", "}", "target", "=", "base", ";", "if", "(", "step1", ">", "0", ")", "{", "rtx", "adjust", ";", "adjust", "=", "GEN_INT", "(", "step1", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "step1", ")", ")", "{", "emit_move_insn", "(", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ",", "adjust", ")", ";", "adjust", "=", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ";", "}", "if", "(", "!", "TARGET_MIPS16", ")", "target", "=", "stack_pointer_rtx", ";", "emit_insn", "(", "gen_add3_insn", "(", "target", ",", "base", ",", "adjust", ")", ")", ";", "}", "if", "(", "target", "!=", "stack_pointer_rtx", ")", "emit_move_insn", "(", "stack_pointer_rtx", ",", "target", ")", ";", "if", "(", "TARGET_ABICALLS", "&&", "TARGET_NEWABI", "&&", "!", "TARGET_EXPLICIT_RELOCS", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "mips_for_each_saved_reg", "(", "cfun", "->", "machine", "->", "frame", ".", "total_size", "-", "step2", ",", "mips_restore_reg", ")", ";", "if", "(", "step2", ">", "0", ")", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "step2", ")", ")", ")", ";", "if", "(", "current_function_calls_eh_return", ")", "{", "if", "(", "TARGET_MIPS16", ")", "{", "emit_move_insn", "(", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ",", "stack_pointer_rtx", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ",", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "MIPS_EPILOGUE_TEMP", "(", "Pmode", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "}", "if", "(", "!", "sibcall_p", ")", "{", "if", "(", "TARGET_MIPS16", "&&", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", "&", "RA_MASK", ")", "!=", "0", ")", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx_REG", "(", "Pmode", ",", "GP_REG_FIRST", "+", "7", ")", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx_REG", "(", "Pmode", ",", "GP_REG_FIRST", "+", "31", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "the", "epilogue", "into", "a", "bunch", "of", "separate", "insns", ".", "SIBCALL_P", "is", "true", "if", "this", "epilogue", "precedes", "a", "sibling", "call", ",", "false", "if", "it", "is", "for", "a", "normal", "``", "epilogue", "''", "pattern", "." ]

[ "mips", "0", "0", "0", "0", "0", "7", "31" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "AArch64FI", "=", "F", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "STI", "=", "static_cast", "<", "const", "AArch64Subtarget", "*", ">", "(", "&", "F", ".", "getSubtarget", "(", ")", ")", ";", "bool", "Result", "=", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";", "emitXRayTable", "(", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "ST", ".", "hasMAIInsts", "(", ")", "&&", "(", "isVGPRClass", "(", "RC", ")", "||", "isAGPRClass", "(", "RC", ")", ")", ")", "{", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VGPR_32RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AGPR_32RegClass", ")", "return", "&", "AMDGPU", "::", "AV_32RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_64RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_64RegClass", ")", "return", "&", "AMDGPU", "::", "AV_64RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_64_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_64_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_64_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_96RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_96RegClass", ")", "return", "&", "AMDGPU", "::", "AV_96RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_96_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_96_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_96_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_128RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_128RegClass", ")", "return", "&", "AMDGPU", "::", "AV_128RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_128_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_128_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_128_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_160RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_160RegClass", ")", "return", "&", "AMDGPU", "::", "AV_160RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_160_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_160_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_160_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_192RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_192RegClass", ")", "return", "&", "AMDGPU", "::", "AV_192RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_192_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_192_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_192_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_256RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_256RegClass", ")", "return", "&", "AMDGPU", "::", "AV_256RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_256_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_256_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_256_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_512RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_512RegClass", ")", "return", "&", "AMDGPU", "::", "AV_512RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_512_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_512_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_512_Align2RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_1024RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_1024RegClass", ")", "return", "&", "AMDGPU", "::", "AV_1024RegClass", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_1024_Align2RegClass", "||", "RC", "==", "&", "AMDGPU", "::", "AReg_1024_Align2RegClass", ")", "return", "&", "AMDGPU", "::", "AV_1024_Align2RegClass", ";", "}", "return", "TargetRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::AGPR_32RegClass", "AMDGPU::AV_32RegClass", "AMDGPU::VReg_64RegClass", "AMDGPU::AReg_64RegClass", "AMDGPU::AV_64RegClass", "AMDGPU::VReg_64_Align2RegClass", "AMDGPU::AReg_64_Align2RegClass", "AMDGPU::AV_64_Align2RegClass", "AMDGPU::VReg_96RegClass", "AMDGPU::AReg_96RegClass", "AMDGPU::AV_96RegClass", "AMDGPU::VReg_96_Align2RegClass", "AMDGPU::AReg_96_Align2RegClass", "AMDGPU::AV_96_Align2RegClass", "AMDGPU::VReg_128RegClass", "AMDGPU::AReg_128RegClass", "AMDGPU::AV_128RegClass", "AMDGPU::VReg_128_Align2RegClass", "AMDGPU::AReg_128_Align2RegClass", "AMDGPU::AV_128_Align2RegClass", "AMDGPU::VReg_160RegClass", "AMDGPU::AReg_160RegClass", "AMDGPU::AV_160RegClass", "AMDGPU::VReg_160_Align2RegClass", "AMDGPU::AReg_160_Align2RegClass", "AMDGPU::AV_160_Align2RegClass", "AMDGPU::VReg_192RegClass", "AMDGPU::AReg_192RegClass", "AMDGPU::AV_192RegClass", "AMDGPU::VReg_192_Align2RegClass", "AMDGPU::AReg_192_Align2RegClass", "AMDGPU::AV_192_Align2RegClass", "AMDGPU::VReg_256RegClass", "AMDGPU::AReg_256RegClass", "AMDGPU::AV_256RegClass", "AMDGPU::VReg_256_Align2RegClass", "AMDGPU::AReg_256_Align2RegClass", "AMDGPU::AV_256_Align2RegClass", "AMDGPU::VReg_512RegClass", "AMDGPU::AReg_512RegClass", "AMDGPU::AV_512RegClass", "AMDGPU::VReg_512_Align2RegClass", "AMDGPU::AReg_512_Align2RegClass", "AMDGPU::AV_512_Align2RegClass", "AMDGPU::VReg_1024RegClass", "AMDGPU::AReg_1024RegClass", "AMDGPU::AV_1024RegClass", "AMDGPU::VReg_1024_Align2RegClass", "AMDGPU::AReg_1024_Align2RegClass", "AMDGPU::AV_1024_Align2RegClass" ]

[]

[ "<s>", "void", "ARMTargetStreamer", "::", "finish", "(", ")", "{", "ConstantPools", "->", "emitAll", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "MCSymbol", "*", "NVPTXAsmPrinter", "::", "getFunctionFrameSymbol", "(", "int", ")", "const", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "(", "Str", ")", "<<", "DEPOTNAME", "<<", "getFunctionNumber", "(", ")", ";", "return", "OutContext", ".", "getOrCreateSymbol", "(", "Str", ")", ";", "}", "</s>" ]

[ "Return", "symbol", "for", "the", "function", "pseudo", "stack", "if", "the", "stack", "frame", "is", "not", "a", "register", "based", "." ]

[ "NVPTX", "NVPTX", "128" ]

[]

[ "<s>", "MCFragment", "*", "AArch64AuthMCExpr", "::", "findAssociatedFragment", "(", ")", "const", "{", "llvm_unreachable", "(", "\"FIXME: what goes here?\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"FIXME: what goes here?\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasVALU32BitEncoding", "(", "unsigned", "Opcode", ")", "const", "{", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_MUL_LEGACY_F32_e64", "&&", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "return", "false", ";", "int", "Op32", "=", "AMDGPU", "::", "getVOPe32", "(", "Opcode", ")", ";", "if", "(", "Op32", "==", "-", "1", ")", "return", "false", ";", "return", "pseudoToMCOpcode", "(", "Op32", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "64-bit", "VALU", "instruction", "has", "a", "32-bit", "encoding", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MUL_LEGACY_F32_e64", "AMDGPU::getVOPe32", "1", "1" ]

[]

[ "<s>", "void", "WebAssemblyAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "const", "MCFixupKindInfo", "&", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Info", ".", "Flags", "==", "0", "&&", "\"WebAssembly does not use MCFixupKindInfo flags\"", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", ",", "8", ")", "/", "8", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\"WebAssembly does not use MCFixupKindInfo flags\"", "8", "8", "0", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "bool", "Cpu0TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "0", "1" ]

[]

[ "<s>", "void", "rs6000_emit_cbranch", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "condition_rtx", "=", "rs6000_generate_compare", "(", "operands", "[", "0", "]", ",", "mode", ")", ";", "rtx", "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ";", "rtx", "ite", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition_rtx", ",", "loc_ref", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "ite", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "branch", "of", "kind", "CODE", "to", "location", "LOC", "." ]

[ "rs6000", "0", "3" ]

[]

[ "<s>", "bool", "FalkorHWPFFix", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "auto", "&", "ST", "=", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "ST", ".", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Falkor", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineLoopInfo", "&", "LI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "Modified", "=", "false", ";", "for", "(", "MachineLoop", "*", "I", ":", "LI", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "I", ")", ",", "LE", "=", "df_end", "(", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "if", "(", "L", "->", "empty", "(", ")", ")", "runOnLoop", "(", "*", "*", "L", ",", "Fn", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "0", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "0" ]

[]

[ "<s>", "static", "tree", "v850_handle_data_area_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "v850_data_area", "data_area", ";", "v850_data_area", "area", ";", "tree", "decl", "=", "*", "node", ";", "if", "(", "is_attribute_p", "(", "\"sda\"", ",", "name", ")", ")", "data_area", "=", "DATA_AREA_SDA", ";", "else", "if", "(", "is_attribute_p", "(", "\"tda\"", ",", "name", ")", ")", "data_area", "=", "DATA_AREA_TDA", ";", "else", "if", "(", "is_attribute_p", "(", "\"zda\"", ",", "name", ")", ")", "data_area", "=", "DATA_AREA_ZDA", ";", "else", "gcc_unreachable", "(", ")", ";", "switch", "(", "TREE_CODE", "(", "decl", ")", ")", "{", "case", "VAR_DECL", ":", "if", "(", "current_function_decl", "!=", "NULL_TREE", ")", "{", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"data area attributes cannot be specified for \"", "\"local variables\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "case", "FUNCTION_DECL", ":", "area", "=", "v850_get_data_area", "(", "decl", ")", ";", "if", "(", "area", "!=", "DATA_AREA_NORMAL", "&&", "data_area", "!=", "area", ")", "{", "error", "(", "\"data area of %q+D conflicts with previous declaration\"", ",", "decl", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "sda", "''", ",", "``", "tda", "''", "or", "``", "zda", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "v850", "\"sda\"", "\"tda\"", "\"zda\"", "\"data area attributes cannot be specified for \"", "\"local variables\"", "\"data area of %q+D conflicts with previous declaration\"" ]

[]

[ "<s>", "bool", "LEGInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "bool", "HasCondBranch", "=", "false", ";", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "LEG", "::", "B", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "HasCondBranch", ")", "{", "FBB", "=", "TargetBB", ";", "}", "else", "{", "TBB", "=", "TargetBB", ";", "}", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "LEG", "::", "Bcc", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "TBB", "=", "TargetBB", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "HasCondBranch", "=", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "LEG::B", "0", "LEG::Bcc", "1", "0" ]

[]

[ "<s>", "bool", "riscv_symbolic_constant_p", "(", "rtx", "x", ",", "enum", "riscv_symbol_type", "*", "symbol_type", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "x", ")", ")", "{", "*", "symbol_type", "=", "UNSPEC_ADDRESS_TYPE", "(", "x", ")", ";", "x", "=", "UNSPEC_ADDRESS", "(", "x", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "*", "symbol_type", "=", "riscv_classify_symbol", "(", "x", ")", ";", "else", "return", "false", ";", "if", "(", "offset", "==", "const0_rtx", ")", "return", "true", ";", "switch", "(", "*", "symbol_type", ")", "{", "case", "SYMBOL_ABSOLUTE", ":", "case", "SYMBOL_PCREL", ":", "case", "SYMBOL_TLS_LE", ":", "return", "sext_hwi", "(", "INTVAL", "(", "offset", ")", ",", "32", ")", "==", "INTVAL", "(", "offset", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbolic", "constant", ".", "If", "it", "is", ",", "store", "the", "type", "of", "the", "symbol", "in", "*", "SYMBOL_TYPE", "." ]

[ "riscv", "32" ]

[]

[ "<s>", "static", "bool", "ix86_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "CC_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_RANDOM", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_PARTIAL_INT", ")", "return", "false", ";", "if", "(", "STACK_REGNO_P", "(", "regno", ")", ")", "return", "VALID_FP_MODE_P", "(", "mode", ")", ";", "if", "(", "MASK_REGNO_P", "(", "regno", ")", ")", "return", "(", "VALID_MASK_REG_MODE", "(", "mode", ")", "||", "(", "TARGET_AVX512BW", "&&", "VALID_MASK_AVX512BW_MODE", "(", "mode", ")", ")", ")", ";", "if", "(", "BND_REGNO_P", "(", "regno", ")", ")", "return", "VALID_BND_REG_MODE", "(", "mode", ")", ";", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "TARGET_AVX512F", "&&", "(", "mode", "==", "XImode", "||", "VALID_AVX512F_REG_MODE", "(", "mode", ")", "||", "VALID_AVX512F_SCALAR_MODE", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_AVX5124FMAPS", "||", "TARGET_AVX5124VNNIW", ")", "&&", "MOD4_SSE_REGNO_P", "(", "regno", ")", "&&", "mode", "==", "V64SFmode", ")", "return", "true", ";", "if", "(", "(", "TARGET_AVX5124FMAPS", "||", "TARGET_AVX5124VNNIW", ")", "&&", "MOD4_SSE_REGNO_P", "(", "regno", ")", "&&", "mode", "==", "V64SImode", ")", "return", "true", ";", "if", "(", "TARGET_AVX512VL", "&&", "(", "mode", "==", "OImode", "||", "mode", "==", "TImode", "||", "VALID_AVX256_REG_MODE", "(", "mode", ")", "||", "VALID_AVX512VL_128_REG_MODE", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "EXT_REX_SSE_REGNO_P", "(", "regno", ")", ")", "return", "false", ";", "return", "(", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_OR_OI_MODE", "(", "mode", ")", ")", "||", "VALID_SSE_REG_MODE", "(", "mode", ")", "||", "VALID_SSE2_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "MMX_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "mode", "==", "QImode", ")", "{", "if", "(", "ANY_QI_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "return", "true", ";", "if", "(", "lra_in_progress", ")", "return", "true", ";", "return", "!", "can_create_pseudo_p", "(", ")", ";", "}", "else", "if", "(", "VALID_INT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_FP_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_DFP_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "i386" ]

[]

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

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

[ "SystemZ" ]

[]

[ "<s>", "unsigned", "GCNSubtarget", "::", "getOccupancyWithNumVGPRs", "(", "unsigned", "VGPRs", ")", "const", "{", "unsigned", "MaxWaves", "=", "getMaxWavesPerEU", "(", ")", ";", "unsigned", "Granule", "=", "getVGPRAllocGranule", "(", ")", ";", "if", "(", "VGPRs", "<", "Granule", ")", "return", "MaxWaves", ";", "unsigned", "RoundedRegs", "=", "(", "(", "VGPRs", "+", "Granule", "-", "1", ")", "/", "Granule", ")", "*", "Granule", ";", "return", "std", "::", "min", "(", "std", "::", "max", "(", "getTotalNumVGPRs", "(", ")", "/", "RoundedRegs", ",", "1u", ")", ",", "MaxWaves", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "waves", "per", "SIMD", "for", "kernels", "using", "VGPRs", "VGPRs", "." ]

[ "AMDGPU", "1", "1u" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"MSP430ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "nullptr", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Alignment", ".", "value", "(", ")", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Alignment", ".", "value", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "MSP430", "\"MSP430ISelAddressMode \"", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "int", "ix86_mode_needed", "(", "int", "entity", ",", "rtx", "insn", ")", "{", "enum", "attr_i387_cw", "mode", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "(", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", ")", ")", ")", "return", "I387_CW_UNINITIALIZED", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "I387_CW_ANY", ";", "mode", "=", "get_attr_i387_cw", "(", "insn", ")", ";", "switch", "(", "entity", ")", "{", "case", "I387_TRUNC", ":", "if", "(", "mode", "==", "I387_CW_TRUNC", ")", "return", "mode", ";", "break", ";", "case", "I387_FLOOR", ":", "if", "(", "mode", "==", "I387_CW_FLOOR", ")", "return", "mode", ";", "break", ";", "case", "I387_CEIL", ":", "if", "(", "mode", "==", "I387_CW_CEIL", ")", "return", "mode", ";", "break", ";", "case", "I387_MASK_PM", ":", "if", "(", "mode", "==", "I387_CW_MASK_PM", ")", "return", "mode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "I387_CW_ANY", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 Promote Constant\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Promote Constant\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "NyuziTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'s'", ":", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Nyuzi", "::", "GPR32RegClass", ")", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Nyuzi", "::", "VR512RegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "1", "0", "0U", "Nyuzi::GPR32RegClass", "0U", "Nyuzi::VR512RegClass" ]

[]

[ "<s>", "static", "void", "aarch64_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "!", "fndecl", "||", "fndecl", "==", "aarch64_previous_fndecl", ")", "return", ";", "tree", "old_tree", "=", "(", "aarch64_previous_fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "aarch64_previous_fndecl", ")", ":", "NULL_TREE", ")", ";", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "!", "new_tree", "&&", "old_tree", ")", "new_tree", "=", "target_option_default_node", ";", "if", "(", "old_tree", "==", "new_tree", ")", "return", ";", "aarch64_previous_fndecl", "=", "fndecl", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "aarch64_save_restore_target_globals", "(", "new_tree", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SET_CURRENT_FUNCTION", ".", "Unpack", "the", "codegen", "decisions", "like", "tuning", "and", "ISA", "features", "from", "the", "DECL_FUNCTION_SPECIFIC_TARGET", "of", "the", "function", ",", "if", "such", "exists", ".", "This", "function", "may", "be", "called", "multiple", "times", "on", "a", "single", "function", "so", "use", "aarch64_previous_fndecl", "to", "avoid", "setting", "up", "identical", "state", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "GCNSubtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "Policy", ".", "ShouldTrackPressure", "=", "true", ";", "Policy", ".", "OnlyTopDown", "=", "false", ";", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "if", "(", "!", "enableSIScheduler", "(", ")", ")", "Policy", ".", "ShouldTrackLaneMasks", "=", "true", ";", "}", "</s>" ]

[ "Override", "generic", "scheduling", "policy", "within", "a", "region", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Promote Constant\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Promote Constant\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineMemOperand", "*", "&", "MMO", ",", "int", "&", "FrameIndex", ")", "const", "{", "for", "(", "MachineInstr", "::", "mmo_iterator", "o", "=", "MI", "->", "memoperands_begin", "(", ")", ",", "oe", "=", "MI", "->", "memoperands_end", "(", ")", ";", "o", "!=", "oe", ";", "++", "o", ")", "{", "if", "(", "(", "*", "o", ")", "->", "isLoad", "(", ")", "&&", "(", "*", "o", ")", "->", "getValue", "(", ")", ")", "if", "(", "const", "FixedStackPseudoSourceValue", "*", "Value", "=", "dyn_cast", "<", "const", "FixedStackPseudoSourceValue", ">", "(", "(", "*", "o", ")", "->", "getValue", "(", ")", ")", ")", "{", "FrameIndex", "=", "Value", "->", "getFrameIndex", "(", ")", ";", "MMO", "=", "*", "o", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "load", "from", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "TargetIRAnalysis", "XCoreTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "XCoreTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "XCore", "XCore", "XCore" ]

[]

[ "<s>", "unsigned", "int", "darwin_rs6000_special_round_type_align", "(", "tree", "type", ",", "unsigned", "int", "computed", ",", "unsigned", "int", "specified", ")", "{", "unsigned", "int", "align", "=", "MAX", "(", "computed", ",", "specified", ")", ";", "if", "(", "TYPE_PACKED", "(", "type", ")", ")", "return", "align", ";", "do", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "!", "field", ")", "break", ";", "if", "(", "DECL_PACKED", "(", "field", ")", ")", "return", "align", ";", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "}", "while", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "type", "!=", "error_mark_node", ")", "align", "=", "MAX", "(", "align", ",", "TYPE_ALIGN", "(", "type", ")", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Darwin", "increases", "record", "alignment", "to", "the", "natural", "alignment", "of", "the", "first", "field", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "bool", "mem_ok_for_ldrd_strd", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "base", "!=", "NULL", "&&", "offset", "!=", "NULL", ")", ";", "if", "(", "side_effects_p", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "SUBREG", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "*", "offset", "=", "const0_rtx", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "arm_legitimate_address_p", "(", "DImode", ",", "addr", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "MINUS", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "REG_P", "(", "*", "base", ")", "&&", "CONST_INT_P", "(", "*", "offset", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "for", "gen_operands_ldrd_strd", ".", "Returns", "true", "iff", "the", "memory", "operand", "MEM", "'s", "address", "contains", "an", "immediate", "offset", "from", "the", "base", "register", "and", "has", "no", "side", "effects", ",", "in", "which", "case", "it", "sets", "BASE", "and", "OFFSET", "accordingly", "." ]

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

[]

[ "<s>", "bool", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ")", "const", "{", "InternalInstruction", "internalInstr", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "void", "*", ")", "&", "region", ",", "logger", ",", "(", "void", "*", ")", "&", "vStream", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "false", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "translateInstruction", "(", "instr", ",", "internalInstr", ")", ";", "return", "true", ";", "}", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "ix86_class_likely_spilled_p", "(", "reg_class_t", "rclass", ")", "{", "switch", "(", "rclass", ")", "{", "case", "AREG", ":", "case", "DREG", ":", "case", "CREG", ":", "case", "BREG", ":", "case", "AD_REGS", ":", "case", "SIREG", ":", "case", "DIREG", ":", "case", "SSE_FIRST_REG", ":", "case", "FP_TOP_REG", ":", "case", "FP_SECOND_REG", ":", "case", "BND_REGS", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CLASS_LIKELY_SPILLED_P", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "OR1KPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createOR1KDelaySlotFillerPass", "(", "getOR1KTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K", "OR1K" ]

[]

[ "<s>", "static", "pad_direction", "s390_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "s390_function_arg_vector", "(", "mode", ",", "type", ")", ")", "return", "PAD_UPWARD", ";", "return", "default_function_arg_padding", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", ".", "Vector", "arguments", "are", "left-justified", "when", "placed", "on", "the", "stack", "during", "parameter", "passing", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "{", "if", "(", "unsigned", "CondOpcode", "=", "getConditionalMove", "(", "Opcode", ")", ")", "{", "MI", "->", "setDesc", "(", "get", "(", "CondOpcode", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::CC" ]

[]

[ "<s>", "bool", "toc_relative_expr_p", "(", "const_rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "!", "TARGET_TOC", ")", "return", "false", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", ")", "{", "if", "(", "strict", "&&", "!", "(", "GET_CODE", "(", "op", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", "&&", "INT_REG_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "0", ")", ",", "strict", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "LO_SUM", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "}", "tocrel_base", "=", "op", ";", "tocrel_offset", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "add_cint_operand", "(", "XEXP", "(", "op", ",", "1", ")", ",", "GET_MODE", "(", "op", ")", ")", ")", "{", "tocrel_base", "=", "XEXP", "(", "op", ",", "0", ")", ";", "tocrel_offset", "=", "XEXP", "(", "op", ",", "1", ")", ";", "}", "return", "(", "GET_CODE", "(", "tocrel_base", ")", "==", "UNSPEC", "&&", "XINT", "(", "tocrel_base", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "toc", "pointer", "relative", "address", "(", "the", "output", "of", "create_TOC_reference", ")", ".", "If", "STRICT", ",", "do", "not", "match", "high", "part", "or", "non-split", "-mcmodel=large/medium", "toc", "pointer", "relative", "addresses", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM A15 S->D optimizer\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM A15 S->D optimizer\"" ]

[]

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

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

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

[]

[ "<s>", "tree", "rs6000_builtin_decl", "(", "unsigned", "code", ",", "bool", ")", "{", "rs6000_gen_builtins", "fcode", "=", "(", "rs6000_gen_builtins", ")", "code", ";", "if", "(", "fcode", ">=", "RS6000_OVLD_MAX", ")", "return", "error_mark_node", ";", "return", "rs6000_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Returns", "the", "rs6000", "builtin", "decl", "for", "CODE", "." ]

[ "rs6000" ]

[]

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

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

[ "MCS51", "\"MCS51 Assembly Printer\"" ]

[]

[ "<s>", "const", "char", "*", "ashrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "6", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %C0,7\"", "CR_TAB", "\"dec %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %D1,7\"", "CR_TAB", "\"dec %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "4", ",", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "5", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "else", "return", "*", "len", "=", "6", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "6", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %B0,%D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "case", "31", ":", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "4", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"movw %C0,%A0\"", ")", ";", "else", "return", "*", "len", "=", "5", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"mov %C0,%A0\"", "CR_TAB", "\"mov %D0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "32bit", "arithmetic", "shift", "right", "(", "(", "signed", "long", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "8", "0", "1", "6", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"sbrc %C0,7\"", "\"dec %D0\"", "\"clr %D0\"", "\"sbrc %D1,7\"", "\"dec %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "4", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "5", "\"movw %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "6", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "24", "6", "\"mov %A0,%D1\"", "\"clr %D0\"", "\"sbrc %A0,7\"", "\"com %D0\"", "\"mov %B0,%D0\"", "\"mov %C0,%D0\"", "2", "32", "31", "4", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"movw %C0,%A0\"", "5", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"mov %C0,%A0\"", "\"mov %D0,%A0\"", "\"asr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\"" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "8", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "Z80", "Z80", "8" ]

[]

[ "<s>", "inline", "bool", "isCatch", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "case", "WebAssembly", "::", "CATCH", ":", "case", "WebAssembly", "::", "CATCH_S", ":", "case", "WebAssembly", "::", "CATCH_ALL", ":", "case", "WebAssembly", "::", "CATCH_ALL_S", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "'true", "'", "if", "the", "clause", "and", "index", "Idx", "is", "a", "catch", "clause", "." ]

[ "WebAssembly", "WebAssembly::CATCH", "WebAssembly::CATCH_S", "WebAssembly::CATCH_ALL", "WebAssembly::CATCH_ALL_S" ]

[]

[ "<s>", "static", "bool", "lm32_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", ")", "{", "return", "G_REG_P", "(", "regno", ")", ";", "}", "</s>" ]

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

[ "lm32" ]

[]

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

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

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "VT", "=", "Outs", "[", "i", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "CC_RISCV", "(", "MF", ".", "getDataLayout", "(", ")", ",", "i", ",", "VT", ",", "VT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ",", "true", ",", "true", ",", "nullptr", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "RISCV", "RISCV", "ISD::OutputArg", "16", "0", "ISD::ArgFlagsTy", "RISCV" ]

[]

[ "<s>", "void", "AAPPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "addPass", "(", "createAAPShortInstrPeepholePass", "(", "getAAPTargetMachine", "(", ")", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "AAP", "AAP" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "if", "(", "ST", "->", "getValue", "(", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "ST", "->", "isTruncatingStore", "(", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "bool", "isInc", "=", "false", ";", "bool", "isLegal", "=", "getIndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "isLegal", ")", "{", "auto", "&", "HII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "int32_t", "OffsetVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", "->", "getSExtValue", "(", ")", ";", "if", "(", "HII", ".", "isValidAutoIncImm", "(", "VT", ",", "OffsetVal", ")", ")", "{", "AM", "=", "isInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "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", "." ]

[ "Hexagon", "Hexagon", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "MVT::i64", "ISD::POST_INC", "ISD::POST_DEC" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "Nyuzi" ]

[]

[ "<s>", "static", "rtx", "frv_io_address_cookie", "(", "rtx", "address", ")", "{", "return", "(", "GET_CODE", "(", "address", ")", "==", "CONST_INT", "?", "GEN_INT", "(", "INTVAL", "(", "address", ")", "/", "8", "*", "8", ")", ":", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Given", "that", "a", "__builtin_read", "or", "__builtin_write", "function", "is", "accessing", "address", "ADDRESS", ",", "return", "the", "value", "that", "should", "be", "used", "as", "operand", "1", "of", "the", "membar", "." ]

[ "frv", "8", "8" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "VT", "=", "VA", ".", "getValVT", "(", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "0", "2" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "optimizeLoadInstr", "(", "MachineInstr", "*", "MI", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "unsigned", "&", "FoldAsLoadDefReg", ",", "MachineInstr", "*", "&", "DefMI", ")", "const", "{", "if", "(", "FoldAsLoadDefReg", "==", "0", ")", "return", "0", ";", "if", "(", "MI", "->", "mayLoad", "(", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "0", ";", "}", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "FoldAsLoadDefReg", ")", ";", "assert", "(", "DefMI", ")", ";", "bool", "SawStore", "=", "false", ";", "if", "(", "!", "DefMI", "->", "isSafeToMove", "(", "this", ",", "0", ",", "SawStore", ")", ")", "return", "0", ";", "unsigned", "IdxEnd", "=", "(", "MI", "->", "isCommutable", "(", ")", ")", "?", "2", ":", "1", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "IdxEnd", ";", "Idx", "++", ")", "{", "unsigned", "SrcOperandId", "=", "0", ";", "bool", "FoundSrcOperand", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "FoldAsLoadDefReg", ")", "continue", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "FoundSrcOperand", ")", "return", "0", ";", "SrcOperandId", "=", "i", ";", "FoundSrcOperand", "=", "true", ";", "}", "if", "(", "!", "FoundSrcOperand", ")", "return", "0", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "Ops", ";", "Ops", ".", "push_back", "(", "SrcOperandId", ")", ";", "MachineInstr", "*", "FoldMI", "=", "foldMemoryOperand", "(", "MI", ",", "Ops", ",", "DefMI", ")", ";", "if", "(", "FoldMI", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "FoldMI", ";", "}", "if", "(", "Idx", "==", "1", ")", "{", "commuteInstruction", "(", "MI", ",", "false", ")", ";", "return", "0", ";", "}", "if", "(", "MI", "->", "isCommutable", "(", ")", ")", "{", "MachineInstr", "*", "NewMI", "=", "commuteInstruction", "(", "MI", ",", "false", ")", ";", "if", "(", "!", "NewMI", ")", "return", "0", ";", "if", "(", "NewMI", "!=", "MI", ")", "{", "NewMI", "->", "eraseFromParent", "(", ")", ";", "return", "0", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "optimizeLoadInstr", "-", "Try", "to", "remove", "the", "load", "by", "folding", "it", "to", "a", "register", "operand", "at", "the", "use", "." ]

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

[]

[ "<s>", "int", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "SDNode", "*", "Node", ")", "const", "override", "{", "return", "1", ";", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "R600", "1" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "emitBasicBlockEnd", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "if", "(", "Subtarget", "->", "hardenSlsRet", "(", ")", "||", "Subtarget", "->", "hardenSlsIJmp", "(", ")", ")", "{", "auto", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "{", "if", "(", "(", "Subtarget", "->", "hardenSlsRet", "(", ")", "&&", "isSimpleReturn", "(", "*", "I", ")", ")", "||", "(", "Subtarget", "->", "hardenSlsIJmp", "(", ")", "&&", "isIndirectBranchOrTailCall", "(", "*", "I", ")", ")", ")", "{", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "X86", "::", "INT3", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "}", "}", "AsmPrinter", "::", "emitBasicBlockEnd", "(", "MBB", ")", ";", "SMShadowTracker", ".", "emitShadowPadding", "(", "*", "OutStreamer", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "at", "the", "end", "of", "a", "basic", "block", "." ]

[ "X86", "X86", "X86::INT3" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "AAP" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "SISubtarget", "&", "STM", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", ".", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "\"Must be run on SSA\"", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandPUSH_POP", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "MCInstrDesc", "&", "Desc", ",", "bool", "IsPush", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "MachineOperand", "MO", "=", "MIB", "->", "getOperand", "(", "0", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "IsPush", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "Desc", ")", ".", "addReg", "(", "RI", ".", "getStackRegister", "(", ")", ")", ".", "add", "(", "MO", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "Desc", ",", "MO", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "RI", ".", "getStackRegister", "(", ")", ")", ";", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Push/Pop", "to/from", "stack", "." ]

[ "M68k", "M68k", "0" ]

[]

[ "<s>", "void", "Z80AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unimplemented\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "SparcTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "SparcPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "void", "pru_set_current_function", "(", "tree", "fndecl", ")", "{", "tree", "old_tree", "=", "(", "pru_previous_fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "pru_previous_fndecl", ")", ":", "NULL_TREE", ")", ";", "tree", "new_tree", "=", "(", "fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ":", "NULL_TREE", ")", ";", "if", "(", "fndecl", "&&", "fndecl", "!=", "pru_previous_fndecl", ")", "{", "pru_previous_fndecl", "=", "fndecl", ";", "if", "(", "old_tree", "==", "new_tree", ")", ";", "else", "if", "(", "new_tree", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "target_reinit", "(", ")", ";", "}", "else", "if", "(", "old_tree", ")", "{", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_current_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "def", ")", ";", "target_reinit", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "pru" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "TargetSubtargetInfo", ">", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "int", "visium_data_alignment", "(", "tree", "type", ",", "unsigned", "int", "align", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "align", "<", "32", ")", "{", "if", "(", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ">=", "32", ")", "return", "32", ";", "if", "(", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ">=", "16", "&&", "align", "<", "16", ")", "return", "16", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "variable", ".", "The", "alignment", "of", "an", "aggregate", "is", "set", "to", "be", "at", "least", "that", "of", "a", "scalar", "less", "than", "or", "equal", "to", "it", "in", "size", "." ]

[ "visium", "32", "32", "32", "16", "16", "16" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "convertToThreeAddress", "(", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "if", "(", "LogicOp", "And", "=", "interpretAndImmediate", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "uint64_t", "Imm", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<<", "And", ".", "ImmLSB", ";", "Imm", "|=", "allOnes", "(", "And", ".", "RegSize", ")", "&", "~", "(", "allOnes", "(", "And", ".", "ImmSize", ")", "<<", "And", ".", "ImmLSB", ")", ";", "unsigned", "Start", ",", "End", ";", "if", "(", "isRxSBGMask", "(", "Imm", ",", "And", ".", "RegSize", ",", "Start", ",", "End", ")", ")", "{", "unsigned", "NewOpcode", ";", "if", "(", "And", ".", "RegSize", "==", "64", ")", "{", "NewOpcode", "=", "SystemZ", "::", "RISBG", ";", "if", "(", "STI", ".", "hasMiscellaneousExtensions", "(", ")", ")", "NewOpcode", "=", "SystemZ", "::", "RISBGN", ";", "}", "else", "{", "NewOpcode", "=", "SystemZ", "::", "RISBMux", ";", "Start", "&=", "31", ";", "End", "&=", "31", ";", "}", "MachineOperand", "&", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpcode", ")", ")", ".", "add", "(", "Dest", ")", ".", "addReg", "(", "0", ")", ".", "addReg", "(", "Src", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "Src", ".", "isKill", "(", ")", ")", ",", "Src", ".", "getSubReg", "(", ")", ")", ".", "addImm", "(", "Start", ")", ".", "addImm", "(", "End", "+", "128", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "LV", ")", "{", "unsigned", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "I", "=", "1", ";", "I", "<", "NumOps", ";", "++", "I", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isKill", "(", ")", ")", "LV", "->", "replaceKillInstruction", "(", "Op", ".", "getReg", "(", ")", ",", "MI", ",", "*", "MIB", ")", ";", "}", "}", "if", "(", "LIS", ")", "LIS", "->", "ReplaceMachineInstrInMaps", "(", "MI", ",", "*", "MIB", ")", ";", "transferDeadCC", "(", "&", "MI", ",", "MIB", ")", ";", "return", "MIB", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "SystemZ", "SystemZ", "2", "64", "SystemZ::RISBG", "SystemZ::RISBGN", "SystemZ::RISBMux", "31", "31", "0", "1", "0", "128", "0", "1" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "StringRef", "SIRegisterInfo", "::", "getRegAsmName", "(", "unsigned", "Reg", ")", "const", "{", "if", "(", "Reg", ">=", "BeginReg", "&&", "Reg", "<=", "EndReg", ")", "{", "\\", "unsigned", "Index", "=", "Reg", "-", "BeginReg", ";", "\\", "assert", "(", "Index", "<", "array_lengthof", "(", "RegTable", ")", ")", ";", "\\", "return", "RegTable", "[", "Index", "]", ";", "\\", "}", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0", ",", "AMDGPU", "::", "VGPR255", ",", "VGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0", ",", "AMDGPU", "::", "SGPR105", ",", "SGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "AGPR0", ",", "AMDGPU", "::", "AGPR255", ",", "AGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1", ",", "AMDGPU", "::", "VGPR254_VGPR255", ",", "VGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1", ",", "AMDGPU", "::", "SGPR104_SGPR105", ",", "SGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "AGPR0_AGPR1", ",", "AMDGPU", "::", "AGPR254_AGPR255", ",", "AGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2", ",", "AMDGPU", "::", "VGPR253_VGPR254_VGPR255", ",", "VGPR96RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3", ",", "AMDGPU", "::", "VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "AMDGPU", "::", "SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "AGPR0_AGPR1_AGPR2_AGPR3", ",", "AMDGPU", "::", "AGPR252_AGPR253_AGPR254_AGPR255", ",", "AGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", ",", "AMDGPU", "::", "VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", ",", "AMDGPU", "::", "VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR512RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "AGPR0_AGPR1_AGPR2_AGPR3_AGPR4_AGPR5_AGPR6_AGPR7_AGPR8_AGPR9_AGPR10_AGPR11_AGPR12_AGPR13_AGPR14_AGPR15", ",", "AMDGPU", "::", "AGPR240_AGPR241_AGPR242_AGPR243_AGPR244_AGPR245_AGPR246_AGPR247_AGPR248_AGPR249_AGPR250_AGPR251_AGPR252_AGPR253_AGPR254_AGPR255", ",", "AGPR512RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", ",", "AMDGPU", "::", "SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", ",", "AMDGPU", "::", "SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR512RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "AGPR0_AGPR1_AGPR2_AGPR3_AGPR4_AGPR5_AGPR6_AGPR7_AGPR8_AGPR9_AGPR10_AGPR11_AGPR12_AGPR13_AGPR14_AGPR15_AGPR16_AGPR17_AGPR18_AGPR19_AGPR20_AGPR21_AGPR22_AGPR23_AGPR24_AGPR25_AGPR26_AGPR27_AGPR28_AGPR29_AGPR30_AGPR31", ",", "AMDGPU", "::", "AGPR224_AGPR225_AGPR226_AGPR227_AGPR228_AGPR229_AGPR230_AGPR231_AGPR232_AGPR233_AGPR234_AGPR235_AGPR236_AGPR237_AGPR238_AGPR239_AGPR240_AGPR241_AGPR242_AGPR243_AGPR244_AGPR245_AGPR246_AGPR247_AGPR248_AGPR249_AGPR250_AGPR251_AGPR252_AGPR253_AGPR254_AGPR255", ",", "AGPR1024RegNames", ")", ";", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "FLAT_SCR", ":", "return", "\"flat_scratch\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "return", "\"flat_scratch_lo\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "return", "\"flat_scratch_hi\"", ";", "default", ":", "return", "TargetRegisterInfo", "::", "getRegAsmName", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "assembly", "name", "for", "Reg", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR0", "AMDGPU::VGPR255", "AMDGPU::SGPR0", "AMDGPU::SGPR105", "AMDGPU::AGPR0", "AMDGPU::AGPR255", "AMDGPU::VGPR0_VGPR1", "AMDGPU::VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1", "AMDGPU::SGPR104_SGPR105", "AMDGPU::AGPR0_AGPR1", "AMDGPU::AGPR254_AGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2", "AMDGPU::VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3", "AMDGPU::VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::AGPR0_AGPR1_AGPR2_AGPR3", "AMDGPU::AGPR252_AGPR253_AGPR254_AGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", "AMDGPU::VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", "AMDGPU::VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::AGPR0_AGPR1_AGPR2_AGPR3_AGPR4_AGPR5_AGPR6_AGPR7_AGPR8_AGPR9_AGPR10_AGPR11_AGPR12_AGPR13_AGPR14_AGPR15", "AMDGPU::AGPR240_AGPR241_AGPR242_AGPR243_AGPR244_AGPR245_AGPR246_AGPR247_AGPR248_AGPR249_AGPR250_AGPR251_AGPR252_AGPR253_AGPR254_AGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", "AMDGPU::SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", "AMDGPU::SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::AGPR0_AGPR1_AGPR2_AGPR3_AGPR4_AGPR5_AGPR6_AGPR7_AGPR8_AGPR9_AGPR10_AGPR11_AGPR12_AGPR13_AGPR14_AGPR15_AGPR16_AGPR17_AGPR18_AGPR19_AGPR20_AGPR21_AGPR22_AGPR23_AGPR24_AGPR25_AGPR26_AGPR27_AGPR28_AGPR29_AGPR30_AGPR31", "AMDGPU::AGPR224_AGPR225_AGPR226_AGPR227_AGPR228_AGPR229_AGPR230_AGPR231_AGPR232_AGPR233_AGPR234_AGPR235_AGPR236_AGPR237_AGPR238_AGPR239_AGPR240_AGPR241_AGPR242_AGPR243_AGPR244_AGPR245_AGPR246_AGPR247_AGPR248_AGPR249_AGPR250_AGPR251_AGPR252_AGPR253_AGPR254_AGPR255", "AMDGPU::FLAT_SCR", "\"flat_scratch\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_HI", "\"flat_scratch_hi\"" ]

[]

[ "<s>", "static", "void", "c6x_hwloops", "(", "void", ")", "{", "if", "(", "optimize", ")", "reorg_loops", "(", "true", ",", "&", "c6x_doloop_hooks", ")", ";", "}", "</s>" ]

[ "Run", "the", "hw-doloop", "pass", "to", "modulo-schedule", "hardware", "loops", ",", "or", "split", "the", "doloop_end", "patterns", "where", "such", "optimizations", "are", "impossible", "." ]

[ "c6x" ]

[]

[ "<s>", "opt_machine_mode", "aarch64_ptrue_all_mode", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "x", ")", "==", "VNx16BImode", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_VECTOR", "||", "!", "CONST_VECTOR_DUPLICATE_P", "(", "x", ")", "||", "!", "CONST_INT_P", "(", "CONST_VECTOR_ENCODED_ELT", "(", "x", ",", "0", ")", ")", "||", "INTVAL", "(", "CONST_VECTOR_ENCODED_ELT", "(", "x", ",", "0", ")", ")", "==", "0", ")", "return", "opt_machine_mode", "(", ")", ";", "unsigned", "int", "nelts", "=", "const_vector_encoded_nelts", "(", "x", ")", ";", "for", "(", "unsigned", "int", "i", "=", "1", ";", "i", "<", "nelts", ";", "++", "i", ")", "if", "(", "CONST_VECTOR_ENCODED_ELT", "(", "x", ",", "i", ")", "!=", "const0_rtx", ")", "return", "opt_machine_mode", "(", ")", ";", "return", "aarch64_sve_pred_mode", "(", "nelts", ")", ";", "}", "</s>" ]

[ "If", "VNx16BImode", "rtx", "X", "is", "a", "canonical", "PTRUE", "for", "a", "predicate", "mode", ",", "return", "that", "predicate", "mode", ",", "otherwise", "return", "opt_machine_mode", "(", ")", "." ]

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

[]

[ "<s>", "void", "rs6000_cost_data", "::", "update_target_cost_per_stmt", "(", "vect_cost_for_stmt", "kind", ",", "stmt_vec_info", "stmt_info", ",", "vect_cost_model_location", "where", ",", "unsigned", "int", "orig_count", ")", "{", "if", "(", "kind", "==", "vec_to_scalar", "||", "kind", "==", "vec_perm", "||", "kind", "==", "vec_promote_demote", "||", "kind", "==", "vec_construct", "||", "kind", "==", "scalar_to_vec", "||", "(", "where", "==", "vect_body", "&&", "kind", "==", "vector_stmt", ")", ")", "m_vect_nonmem", "=", "true", ";", "if", "(", "!", "m_costing_for_scalar", "&&", "is_a", "<", "loop_vec_info", ">", "(", "m_vinfo", ")", "&&", "where", "==", "vect_body", ")", "{", "m_nstmts", "+=", "orig_count", ";", "if", "(", "kind", "==", "scalar_load", "||", "kind", "==", "vector_load", "||", "kind", "==", "unaligned_load", "||", "kind", "==", "vector_gather_load", ")", "{", "m_nloads", "+=", "orig_count", ";", "if", "(", "stmt_info", "&&", "STMT_VINFO_GATHER_SCATTER_P", "(", "stmt_info", ")", ")", "m_gather_load", "=", "true", ";", "}", "else", "if", "(", "kind", "==", "scalar_store", "||", "kind", "==", "vector_store", "||", "kind", "==", "unaligned_store", "||", "kind", "==", "vector_scatter_store", ")", "m_nstores", "+=", "orig_count", ";", "else", "if", "(", "(", "kind", "==", "scalar_stmt", "||", "kind", "==", "vector_stmt", "||", "kind", "==", "vec_to_scalar", ")", "&&", "stmt_info", "&&", "vect_is_reduction", "(", "stmt_info", ")", ")", "{", "tree", "lhs", "=", "gimple_get_lhs", "(", "stmt_info", "->", "stmt", ")", ";", "bool", "is_float", "=", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "lhs", ")", ")", ";", "unsigned", "int", "basic_cost", "=", "is_float", "?", "2", ":", "1", ";", "m_reduc_factor", "=", "MAX", "(", "basic_cost", "*", "orig_count", ",", "m_reduc_factor", ")", ";", "}", "if", "(", "kind", "==", "vec_construct", "&&", "stmt_info", "&&", "STMT_VINFO_TYPE", "(", "stmt_info", ")", "==", "load_vec_info_type", "&&", "(", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_ELEMENTWISE", "||", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_STRIDED_SLP", ")", ")", "{", "tree", "vectype", "=", "STMT_VINFO_VECTYPE", "(", "stmt_info", ")", ";", "unsigned", "int", "nunits", "=", "vect_nunits_for_cost", "(", "vectype", ")", ";", "if", "(", "nunits", "==", "1", ")", "return", ";", "unsigned", "int", "adjusted_cost", "=", "(", "nunits", "==", "2", ")", "?", "2", ":", "1", ";", "unsigned", "int", "extra_cost", "=", "nunits", "*", "adjusted_cost", ";", "m_extra_ctor_cost", "+=", "extra_cost", ";", "}", "}", "}", "</s>" ]

[ "Helper", "function", "for", "add_stmt_cost", ".", "Check", "each", "statement", "cost", "entry", ",", "gather", "information", "and", "update", "the", "target_cost", "fields", "accordingly", "." ]

[ "rs6000", "2", "1", "1", "2", "2", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 branch relaxation pass\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 branch relaxation pass\"" ]

[]

[ "<s>", "bool", "microblaze_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "contains", "any", "TLS", "symbol", "references", "." ]

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

[]

[ "<s>", "static", "bool", "mips_classify_address", "(", "struct", "mips_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "mips_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "mips_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "mips_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "case", "LO_SUM", ":", "info", "->", "type", "=", "ADDRESS_LO_SUM", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "info", "->", "symbol_type", "=", "mips_classify_symbolic_expression", "(", "info", "->", "offset", ",", "SYMBOL_CONTEXT_MEM", ")", ";", "return", "(", "mips_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "mips_valid_lo_sum_p", "(", "info", "->", "symbol_type", ",", "mode", ")", ")", ";", "case", "CONST_INT", ":", "info", "->", "type", "=", "ADDRESS_CONST_INT", ";", "return", "!", "TARGET_MIPS16", "&&", "SMALL_INT", "(", "x", ")", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "info", "->", "type", "=", "ADDRESS_SYMBOLIC", ";", "return", "(", "mips_symbolic_constant_p", "(", "x", ",", "SYMBOL_CONTEXT_MEM", ",", "&", "info", "->", "symbol_type", ")", "&&", "mips_symbol_insns", "(", "info", "->", "symbol_type", ",", "mode", ")", ">", "0", "&&", "!", "mips_split_p", "[", "info", "->", "symbol_type", "]", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT", "is", "true", "if", "we", "should", "only", "accept", "hard", "base", "registers", "." ]

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

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "void", "ix86_expand_reduc", "(", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "rtx", "dest", ",", "rtx", "in", ")", "{", "rtx", "half", ",", "dst", ",", "vec", "=", "in", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "in", ")", ";", "int", "i", ";", "if", "(", "TARGET_SSE4_1", "&&", "mode", "==", "V8HImode", "&&", "fn", "==", "gen_uminv8hi3", ")", "{", "emit_insn", "(", "gen_sse4_1_phminposuw", "(", "dest", ",", "in", ")", ")", ";", "return", ";", "}", "for", "(", "i", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "i", ">", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "i", ">>=", "1", ")", "{", "half", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_reduc_half", "(", "half", ",", "vec", ",", "i", ")", ";", "if", "(", "i", "==", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", "*", "2", ")", "dst", "=", "dest", ";", "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "fn", "(", "dst", ",", "half", ",", "vec", ")", ")", ";", "vec", "=", "dst", ";", "}", "}", "</s>" ]

[ "Expand", "a", "vector", "reduction", ".", "FN", "is", "the", "binary", "pattern", "to", "reduce", ";", "DEST", "is", "the", "destination", ";", "IN", "is", "the", "input", "vector", "." ]

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

[]