Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "nios2_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "to", "=", "operands", "[", "0", "]", ";", "rtx", "from", "=", "operands", "[", "1", "]", ";", "if", "(", "!", "register_operand", "(", "to", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "from", ",", "mode", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "from", "=", "copy_to_mode_reg", "(", "mode", ",", "from", ")", ";", "}", "if", "(", "GET_CODE", "(", "from", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "from", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "from", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "from", ",", "0", ")", ")", "!=", "UNSPEC", ")", ")", "from", "=", "nios2_legitimize_constant_address", "(", "from", ")", ";", "operands", "[", "0", "]", "=", "to", ";", "operands", "[", "1", "]", "=", "from", ";", "return", "0", ";", "}", "</s>" ]

[ "Main", "expander", "function", "for", "RTL", "moves", "." ]

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

[]

[ "<s>", "static", "const", "struct", "mips_cpu_info", "*", "mips_cpu_info_from_opt", "(", "int", "opt", ")", "{", "switch", "(", "opt", ")", "{", "case", "MIPS_ARCH_OPTION_FROM_ABI", ":", "return", "mips_cpu_info_from_isa", "(", "ABI_NEEDS_32BIT_REGS", "?", "1", ":", "ABI_NEEDS_64BIT_REGS", "?", "3", ":", "(", "TARGET_64BIT", "?", "3", ":", "1", ")", ")", ";", "case", "MIPS_ARCH_OPTION_NATIVE", ":", "gcc_unreachable", "(", ")", ";", "default", ":", "return", "&", "mips_cpu_info_table", "[", "opt", "]", ";", "}", "}", "</s>" ]

[ "Return", "a", "mips_cpu_info", "entry", "determined", "by", "an", "option", "valued", "OPT", "." ]

[ "mips", "1", "3", "3", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Stack Tagging PreRA\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Stack Tagging PreRA\"" ]

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOp", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MB", ".", "getParent", "(", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "HFI", "=", "*", "HST", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BP", "=", "0", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "HFI", ".", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "BP", ")", ";", "int", "RealOffset", "=", "Offset", "+", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "TFR_FIA", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "MI", ".", "RemoveOperand", "(", "FIOp", "+", "1", ")", ";", "return", ";", "case", "Hexagon", "::", "TFR_FI", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "break", ";", "}", "if", "(", "HII", ".", "isValidOffset", "(", "Opc", ",", "RealOffset", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToRegister", "(", "BP", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "return", ";", "}", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "dbgs", "(", ")", "<<", "\"In function \"", ";", "if", "(", "F", ")", "dbgs", "(", ")", "<<", "F", "->", "getName", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"<?>\"", ";", "dbgs", "(", ")", "<<", "\", BB#\"", "<<", "MB", ".", "getNumber", "(", ")", "<<", "\"\\n\"", "<<", "MI", ";", "llvm_unreachable", "(", "\"Unhandled instruction\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Unexpected\"", "Hexagon", "0", "1", "Hexagon::TFR_FIA", "Hexagon::A2_addi", "1", "Hexagon::TFR_FI", "Hexagon::A2_addi", "1", "\"In function \"", "\"<?>\"", "\", BB#\"", "\"\\n\"", "\"Unhandled instruction\"" ]

[]

[ "<s>", "bool", "rs6000_special_adjust_field_align_p", "(", "tree", "type", ",", "unsigned", "int", "computed", ")", "{", "if", "(", "TARGET_ALTIVEC", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "computed", "!=", "128", ")", "{", "static", "bool", "warned", ";", "if", "(", "!", "warned", "&&", "warn_psabi", ")", "{", "warned", "=", "true", ";", "inform", "(", "input_location", ",", "\"the layout of aggregates containing vectors with\"", "\" %d-byte alignment has changed in GCC 5\"", ",", "computed", "/", "BITS_PER_UNIT", ")", ";", "}", "}", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Previous", "GCC", "releases", "forced", "all", "vector", "types", "to", "have", "16-byte", "alignment", "." ]

[ "powerpcspe", "128", "\"the layout of aggregates containing vectors with\"", "\" %d-byte alignment has changed in GCC 5\"" ]

[]

[ "<s>", "const", "unsigned", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "XCore", "::", "LR", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "XCore::LR", "0" ]

[]

[ "<s>", "static", "parse_codes", "parse_prototype", "(", "prototype", "*", "protoptr", ")", "{", "typeinfo", "*", "ret_type", "=", "&", "protoptr", "->", "rettype", ";", "char", "*", "*", "bifname", "=", "&", "protoptr", "->", "bifname", ";", "consume_whitespace", "(", ")", ";", "int", "oldpos", "=", "pos", ";", "int", "success", "=", "match_type", "(", "ret_type", ",", "VOID_OK", ")", ";", "if", "(", "!", "success", ")", "{", "diag", "(", "oldpos", ",", "\"missing or badly formed return type.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "diag", "(", "0", ",", "\"return type: isvoid = %d, isconst = %d, isvector = %d, \"", "\"issigned = %d, isunsigned = %d, isbool = %d, ispixel = %d, \"", "\"ispointer = %d, base = %d, restr = %d, val1 = \\\"%s\\\", \"", "\"val2 = \\\"%s\\\", pos = %d.\\n\"", ",", "ret_type", "->", "isvoid", ",", "ret_type", "->", "isconst", ",", "ret_type", "->", "isvector", ",", "ret_type", "->", "issigned", ",", "ret_type", "->", "isunsigned", ",", "ret_type", "->", "isbool", ",", "ret_type", "->", "ispixel", ",", "ret_type", "->", "ispointer", ",", "ret_type", "->", "base", ",", "ret_type", "->", "restr", ",", "ret_type", "->", "val1", ",", "ret_type", "->", "val2", ",", "pos", "+", "1", ")", ";", "consume_whitespace", "(", ")", ";", "oldpos", "=", "pos", ";", "*", "bifname", "=", "match_identifier", "(", ")", ";", "if", "(", "!", "*", "bifname", ")", "{", "diag", "(", "oldpos", ",", "\"missing function name.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "diag", "(", "0", ",", "\"function name is '%s'.\\n\"", ",", "*", "bifname", ")", ";", "if", "(", "parse_args", "(", "protoptr", ")", "==", "PC_PARSEFAIL", ")", "return", "PC_PARSEFAIL", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "';'", ")", "{", "diag", "(", "pos", ",", "\"missing semicolon.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", ")", "{", "diag", "(", "pos", ",", "\"garbage at end of line.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "return", "PC_OK", ";", "}", "</s>" ]

[ "Parse", "a", "function", "prototype", ".", "This", "code", "is", "shared", "by", "the", "bif", "and", "overload", "file", "processing", "." ]

[ "rs6000", "\"missing or badly formed return type.\\n\"", "0", "\"return type: isvoid = %d, isconst = %d, isvector = %d, \"", "\"issigned = %d, isunsigned = %d, isbool = %d, ispixel = %d, \"", "\"ispointer = %d, base = %d, restr = %d, val1 = \\\"%s\\\", \"", "\"val2 = \\\"%s\\\", pos = %d.\\n\"", "1", "\"missing function name.\\n\"", "0", "\"function name is '%s'.\\n\"", "\"missing semicolon.\\n\"", "\"garbage at end of line.\\n\"" ]

[]

[ "<s>", "MipsTargetLowering", "::", "ConstraintType", "MipsTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "return", "C_RegisterClass", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "PTXPassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", ".", "add", "(", "createPTXMFInfoExtract", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "PM", ".", "add", "(", "createPTXFPRoundingModePass", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX", "PTX", "PTX" ]

[]

[ "<s>", "int", "arc_label_align", "(", "rtx", "label", ")", "{", "int", "loop_align", "=", "LOOP_ALIGN", "(", "LABEL", ")", ";", "if", "(", "loop_align", ">", "align_labels_log", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "label", ")", ";", "if", "(", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "PARALLEL", "&&", "recog_memoized", "(", "prev", ")", "==", "CODE_FOR_doloop_begin_i", ")", "return", "loop_align", ";", "}", "if", "(", "align_labels_log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels_log", ";", "}", "</s>" ]

[ "Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")" ]

[ "arc", "1", "0", "1" ]

[]

[ "<s>", "const", "Cpu0MCExpr", "*", "Cpu0MCExpr", "::", "create", "(", "const", "MCSymbol", "*", "Symbol", ",", "Cpu0MCExpr", "::", "Cpu0ExprKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "const", "MCSymbolRefExpr", "*", "MCSym", "=", "MCSymbolRefExpr", "::", "create", "(", "Symbol", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "Ctx", ")", ";", "return", "new", "(", "Ctx", ")", "Cpu0MCExpr", "(", "Kind", ",", "MCSym", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "parse_mrgf_banked_regs_option", "(", "const", "char", "*", "arg", ")", "{", "long", "int", "val", ";", "char", "*", "end_ptr", ";", "errno", "=", "0", ";", "val", "=", "strtol", "(", "arg", ",", "&", "end_ptr", ",", "10", ")", ";", "if", "(", "errno", "!=", "0", "||", "*", "arg", "==", "'\\0'", "||", "*", "end_ptr", "!=", "'\\0'", "||", "(", "val", "!=", "0", "&&", "val", "!=", "4", "&&", "val", "!=", "8", "&&", "val", "!=", "16", "&&", "val", "!=", "32", ")", ")", "{", "error", "(", "\"invalid number in %<-mrgf-banked-regs=%s%> \"", "\"valid values are 0, 4, 8, 16, or 32\"", ",", "arg", ")", ";", "return", ";", "}", "rgf_banked_register_count", "=", "(", "int", ")", "val", ";", "}", "</s>" ]

[ "Parse", "-mrgf-banked-regs=NUM", "option", "string", ".", "Valid", "values", "for", "NUM", "are", "4", ",", "8", ",", "16", ",", "or", "32", "." ]

[ "arc", "0", "10", "0", "0", "4", "8", "16", "32", "\"invalid number in %<-mrgf-banked-regs=%s%> \"", "\"valid values are 0, 4, 8, 16, or 32\"" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "Nyuzi" ]

[]

[ "<s>", "static", "int", "frv_acc_group_1", "(", "rtx", "*", "x", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "REG_P", "(", "*", "x", ")", ")", "{", "if", "(", "ACC_P", "(", "REGNO", "(", "*", "x", ")", ")", ")", "return", "(", "REGNO", "(", "*", "x", ")", "-", "ACC_FIRST", ")", "&", "4", "?", "ACC_GROUP_ODD", ":", "ACC_GROUP_EVEN", ";", "if", "(", "ACCG_P", "(", "REGNO", "(", "*", "x", ")", ")", ")", "return", "(", "REGNO", "(", "*", "x", ")", "-", "ACCG_FIRST", ")", "&", "4", "?", "ACC_GROUP_ODD", ":", "ACC_GROUP_EVEN", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "A", "for_each_rtx", "callback", ".", "If", "X", "refers", "to", "an", "accumulator", ",", "return", "ACC_GROUP_ODD", "if", "the", "bit", "2", "of", "the", "register", "number", "is", "set", "and", "ACC_GROUP_EVEN", "if", "it", "is", "clear", ".", "Return", "0", "(", "ACC_GROUP_NONE", ")", "otherwise", "." ]

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

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "rtx", "ia64_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "(", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "(", "mode", ")", "!=", "TFmode", ")", "?", "FR_RET_FIRST", ":", "GR_RET_FIRST", ")", ")", ";", "}", "</s>" ]

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

[ "ia64" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Videocore" ]

[]

[ "<s>", "void", "SHUXIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "SHUXI", "::", "PUSH", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "SHUXI::PUSH" ]

[]

[ "<s>", "bool", "CSKYAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CSKY", "::", "JBR32", ":", "case", "CSKY", "::", "JBT32", ":", "case", "CSKY", "::", "JBF32", ":", "case", "CSKY", "::", "JBSR32", ":", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "CSKY", "::", "Has2E3", "]", ")", "return", "false", ";", "return", "true", ";", "case", "CSKY", "::", "JBR16", ":", "case", "CSKY", "::", "JBT16", ":", "case", "CSKY", "::", "JBF16", ":", "case", "CSKY", "::", "LRW16", ":", "case", "CSKY", "::", "BR16", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::JBR32", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBSR32", "CSKY::Has2E3", "CSKY::JBR16", "CSKY::JBT16", "CSKY::JBF16", "CSKY::LRW16", "CSKY::BR16" ]

[]

[ "<s>", "static", "ARMOperand", "CreateMem", "(", "unsigned", "BaseRegNum", ",", "bool", "OffsetIsReg", ",", "const", "MCExpr", "*", "Offset", ",", "unsigned", "OffsetRegNum", ",", "bool", "OffsetRegShifted", ",", "enum", "ShiftType", "ShiftType", ",", "const", "MCExpr", "*", "ShiftAmount", ",", "bool", "Preindexed", ",", "bool", "Postindexed", ",", "bool", "Negative", ",", "bool", "Writeback", ")", "{", "ARMOperand", "Res", ";", "Res", ".", "Kind", "=", "Memory", ";", "Res", ".", "Mem", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Res", ".", "Mem", ".", "OffsetIsReg", "=", "OffsetIsReg", ";", "Res", ".", "Mem", ".", "Offset", "=", "Offset", ";", "Res", ".", "Mem", ".", "OffsetRegNum", "=", "OffsetRegNum", ";", "Res", ".", "Mem", ".", "OffsetRegShifted", "=", "OffsetRegShifted", ";", "Res", ".", "Mem", ".", "ShiftType", "=", "ShiftType", ";", "Res", ".", "Mem", ".", "ShiftAmount", "=", "ShiftAmount", ";", "Res", ".", "Mem", ".", "Preindexed", "=", "Preindexed", ";", "Res", ".", "Mem", ".", "Postindexed", "=", "Postindexed", ";", "Res", ".", "Mem", ".", "Negative", "=", "Negative", ";", "Res", ".", "Mem", ".", "Writeback", "=", "Writeback", ";", "return", "Res", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonRemoveExtendArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "arg_iterator", "AI", "=", "F", ".", "arg_begin", "(", ")", ",", "AE", "=", "F", ".", "arg_end", "(", ")", ";", "AI", "!=", "AE", ";", "++", "AI", ",", "++", "Idx", ")", "{", "if", "(", "F", ".", "getParamAttributes", "(", "Idx", ")", ".", "hasAttribute", "(", "Attributes", "::", "SExt", ")", ")", "{", "Argument", "*", "Arg", "=", "AI", ";", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", "->", "getType", "(", ")", ")", ")", "{", "for", "(", "Instruction", "::", "use_iterator", "UI", "=", "Arg", "->", "use_begin", "(", ")", ";", "UI", "!=", "Arg", "->", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "F", ".", "getEntryBlock", "(", ")", ".", "begin", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1" ]

[]

[ "<s>", "const", "char", "*", "arm_output_shift", "(", "rtx", "*", "operands", ",", "int", "set_flags", ")", "{", "char", "pattern", "[", "100", "]", ";", "static", "const", "char", "flag_chars", "[", "3", "]", "=", "{", "'?'", ",", "'.'", ",", "'!'", "}", ";", "const", "char", "*", "shift", ";", "HOST_WIDE_INT", "val", ";", "char", "c", ";", "c", "=", "flag_chars", "[", "set_flags", "]", ";", "if", "(", "TARGET_UNIFIED_ASM", ")", "{", "shift", "=", "shift_op", "(", "operands", "[", "3", "]", ",", "&", "val", ")", ";", "if", "(", "shift", ")", "{", "if", "(", "val", "!=", "-", "1", ")", "operands", "[", "2", "]", "=", "GEN_INT", "(", "val", ")", ";", "sprintf", "(", "pattern", ",", "\"%s%%%c\\t%%0, %%1, %%2\"", ",", "shift", ",", "c", ")", ";", "}", "else", "sprintf", "(", "pattern", ",", "\"mov%%%c\\t%%0, %%1\"", ",", "c", ")", ";", "}", "else", "sprintf", "(", "pattern", ",", "\"mov%%%c\\t%%0, %%1%%S3\"", ",", "c", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembly", "for", "a", "shift", "instruction", ".", "SET_FLAGS", "determines", "how", "the", "instruction", "modifies", "the", "condition", "codes", ".", "0", "-", "Do", "not", "set", "condition", "codes", ".", "1", "-", "Set", "condition", "codes", ".", "2", "-", "Use", "smallest", "instruction", "." ]

[ "arm", "100", "3", "3", "1", "2", "\"%s%%%c\\t%%0, %%1, %%2\"", "\"mov%%%c\\t%%0, %%1\"", "\"mov%%%c\\t%%0, %%1%%S3\"", "\"\"" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "GETtlsADDR64AIX", ":", "case", "PPC", "::", "GETtlsADDR32AIX", ":", "{", "MCSymbol", "*", "TlsGetAddr", "=", "createMCSymbolForTlsGetAddr", "(", "OutContext", ")", ";", "ExtSymSDNodeSymbols", ".", "insert", "(", "TlsGetAddr", ")", ";", "break", ";", "}", "case", "PPC", "::", "BL8", ":", "case", "PPC", "::", "BL", ":", "case", "PPC", "::", "BL8_NOP", ":", "case", "PPC", "::", "BL_NOP", ":", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "MCSymbolXCOFF", "*", "S", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "OutContext", ".", "getOrCreateSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "ExtSymSDNodeSymbols", ".", "insert", "(", "S", ")", ";", "}", "}", "break", ";", "case", "PPC", "::", "BL_TLS", ":", "case", "PPC", "::", "BL8_TLS", ":", "case", "PPC", "::", "BL8_TLS_", ":", "case", "PPC", "::", "BL8_NOP_TLS", ":", "report_fatal_error", "(", "\"TLS call not yet implemented\"", ")", ";", "case", "PPC", "::", "TAILB", ":", "case", "PPC", "::", "TAILB8", ":", "case", "PPC", "::", "TAILBA", ":", "case", "PPC", "::", "TAILBA8", ":", "case", "PPC", "::", "TAILBCTR", ":", "case", "PPC", "::", "TAILBCTR8", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isSymbol", "(", ")", ")", "report_fatal_error", "(", "\"Tail call for extern symbol not yet supported.\"", ")", ";", "break", ";", "}", "return", "PPCAsmPrinter", "::", "emitInstruction", "(", "MI", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "PowerPC", "PPC", "PPC::GETtlsADDR64AIX", "PPC::GETtlsADDR32AIX", "PPC::BL8", "PPC::BL", "PPC::BL8_NOP", "PPC::BL_NOP", "0", "PPC::BL_TLS", "PPC::BL8_TLS", "PPC::BL8_TLS_", "PPC::BL8_NOP_TLS", "\"TLS call not yet implemented\"", "PPC::TAILB", "PPC::TAILB8", "PPC::TAILBA", "PPC::TAILBA8", "PPC::TAILBCTR", "PPC::TAILBCTR8", "0", "\"Tail call for extern symbol not yet supported.\"", "PPC" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::LDri", "0", "SP::FPRegsRegisterClass", "SP::LDFri", "0", "SP::DFPRegsRegisterClass", "SP::LDDFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "int", "rs6000_clone_priority", "(", "tree", "fndecl", ")", "{", "tree", "fn_opts", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "HOST_WIDE_INT", "isa_masks", ";", "int", "ret", "=", "CLONE_DEFAULT", ";", "tree", "attrs", "=", "lookup_attribute", "(", "\"target\"", ",", "DECL_ATTRIBUTES", "(", "fndecl", ")", ")", ";", "const", "char", "*", "attrs_str", "=", "NULL", ";", "attrs", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "attrs", ")", ")", ";", "attrs_str", "=", "TREE_STRING_POINTER", "(", "attrs", ")", ";", "if", "(", "strcmp", "(", "attrs_str", ",", "\"default\"", ")", "!=", "0", ")", "{", "if", "(", "fn_opts", "==", "NULL_TREE", ")", "fn_opts", "=", "target_option_default_node", ";", "if", "(", "!", "fn_opts", "||", "!", "TREE_TARGET_OPTION", "(", "fn_opts", ")", ")", "isa_masks", "=", "rs6000_isa_flags", ";", "else", "isa_masks", "=", "TREE_TARGET_OPTION", "(", "fn_opts", ")", "->", "x_rs6000_isa_flags", ";", "for", "(", "ret", "=", "CLONE_MAX", "-", "1", ";", "ret", "!=", "0", ";", "ret", "--", ")", "if", "(", "(", "rs6000_clone_map", "[", "ret", "]", ".", "isa_mask", "&", "isa_masks", ")", "!=", "0", ")", "break", ";", "}", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_get_function_version_priority (%s) => %d\\n\"", ",", "get_decl_name", "(", "fndecl", ")", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Return", "the", "clone", "id", "of", "the", "target", "we", "are", "compiling", "code", "for", "in", "a", "target", "clone", ".", "The", "clone", "id", "is", "ordered", "from", "0", "(", "default", ")", "to", "CLONE_MAX-1", "and", "gives", "the", "priority", "list", "for", "the", "target", "clones", "(", "ordered", "from", "lowest", "to", "highest", ")", "." ]

[ "rs6000", "\"target\"", "\"default\"", "0", "1", "0", "0", "\"rs6000_get_function_version_priority (%s) => %d\\n\"" ]

[]

[ "<s>", "OperandMatchResultTy", "VEAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "RegNo", "=", "0", ";", "if", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", "!=", "AsmToken", "::", "Percent", ")", "return", "MatchOperand_NoMatch", ";", "Parser", ".", "Lex", "(", ")", ";", "RegNo", "=", "parseRegisterName", "(", "&", "MatchRegisterName", ")", ";", "if", "(", "RegNo", "==", "VE", "::", "NoRegister", ")", "RegNo", "=", "parseRegisterName", "(", "&", "MatchRegisterAltName", ")", ";", "if", "(", "RegNo", "!=", "VE", "::", "NoRegister", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", "getLexer", "(", ")", ".", "UnLex", "(", "Tok", ")", ";", "return", "MatchOperand_NoMatch", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "VE", "VE", "0", "VE::NoRegister", "VE::NoRegister" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcmp", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "SDValue", "Size", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "if", "(", "ConstantSDNode", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "{", "uint64_t", "Bytes", "=", "CSize", "->", "getZExtValue", "(", ")", ";", "assert", "(", "Bytes", ">", "0", "&&", "\"Caller should have handled 0-size case\"", ")", ";", "Chain", "=", "emitCLC", "(", "DAG", ",", "DL", ",", "Chain", ",", "Src1", ",", "Src2", ",", "Bytes", ")", ";", "SDValue", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "Glue", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "return", "std", "::", "make_pair", "(", "SDValue", "(", ")", ",", "SDValue", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcmp/bcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "0", "\"Caller should have handled 0-size case\"", "1" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLoweredToCall", "(", "const", "Function", "*", "F", ")", "{", "if", "(", "!", "F", "->", "isIntrinsic", "(", ")", ")", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "if", "(", "F", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.arm\"", ")", ")", "return", "false", ";", "switch", "(", "F", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "powi", ":", "case", "Intrinsic", "::", "sin", ":", "case", "Intrinsic", "::", "cos", ":", "case", "Intrinsic", "::", "pow", ":", "case", "Intrinsic", "::", "log", ":", "case", "Intrinsic", "::", "log10", ":", "case", "Intrinsic", "::", "log2", ":", "case", "Intrinsic", "::", "exp", ":", "case", "Intrinsic", "::", "exp2", ":", "return", "true", ";", "case", "Intrinsic", "::", "sqrt", ":", "case", "Intrinsic", "::", "fabs", ":", "case", "Intrinsic", "::", "copysign", ":", "case", "Intrinsic", "::", "floor", ":", "case", "Intrinsic", "::", "ceil", ":", "case", "Intrinsic", "::", "trunc", ":", "case", "Intrinsic", "::", "rint", ":", "case", "Intrinsic", "::", "nearbyint", ":", "case", "Intrinsic", "::", "round", ":", "case", "Intrinsic", "::", "canonicalize", ":", "case", "Intrinsic", "::", "lround", ":", "case", "Intrinsic", "::", "llround", ":", "case", "Intrinsic", "::", "lrint", ":", "case", "Intrinsic", "::", "llrint", ":", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isDoubleTy", "(", ")", "&&", "!", "ST", "->", "hasFP64", "(", ")", ")", "return", "true", ";", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isHalfTy", "(", ")", "&&", "!", "ST", "->", "hasFullFP16", "(", ")", ")", "return", "true", ";", "return", "!", "ST", "->", "hasFPARMv8Base", "(", ")", "&&", "!", "ST", "->", "hasVFP2Base", "(", ")", ";", "case", "Intrinsic", "::", "masked_store", ":", "case", "Intrinsic", "::", "masked_load", ":", "case", "Intrinsic", "::", "masked_gather", ":", "case", "Intrinsic", "::", "masked_scatter", ":", "return", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "uadd_sat", ":", "case", "Intrinsic", "::", "ssub_sat", ":", "case", "Intrinsic", "::", "usub_sat", ":", "return", "false", ";", "}", "return", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "}", "</s>" ]

[ "Test", "whether", "calls", "to", "a", "function", "lower", "to", "actual", "program", "function", "calls", "." ]

[ "ARM", "ARM", "\"llvm.arm\"", "Intrinsic::powi", "Intrinsic::sin", "Intrinsic::cos", "Intrinsic::pow", "Intrinsic::log", "Intrinsic::log10", "Intrinsic::log2", "Intrinsic::exp", "Intrinsic::exp2", "Intrinsic::sqrt", "Intrinsic::fabs", "Intrinsic::copysign", "Intrinsic::floor", "Intrinsic::ceil", "Intrinsic::trunc", "Intrinsic::rint", "Intrinsic::nearbyint", "Intrinsic::round", "Intrinsic::canonicalize", "Intrinsic::lround", "Intrinsic::llround", "Intrinsic::lrint", "Intrinsic::llrint", "ARM", "Intrinsic::masked_store", "Intrinsic::masked_load", "Intrinsic::masked_gather", "Intrinsic::masked_scatter", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::sadd_sat", "Intrinsic::uadd_sat", "Intrinsic::ssub_sat", "Intrinsic::usub_sat" ]

[]

[ "<s>", "static", "bool", "v850_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", ";", "if", "(", "v850_rtx_ok_for_base_p", "(", "x", ",", "strict_p", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", "&&", "(", "mode", "==", "QImode", "||", "INTVAL", "(", "x", ")", "%", "2", "==", "0", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", "||", "INTVAL", "(", "x", ")", "%", "4", "==", "0", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "v850_reg_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "||", "(", "(", "mode", "==", "QImode", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "%", "2", "==", "0", ")", "&&", "constraint_satisfied_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "CONSTRAINT_K", ")", ")", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "return", "true", ";", "if", "(", "special_symbolref_operand", "(", "x", ",", "mode", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "GET_MODE_SIZE", "(", "word_mode", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "v850_rtx_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "(", "constraint_satisfied_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "CONSTRAINT_K", ")", "||", "(", "TARGET_V850E2V3_UP", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", "&&", "constraint_satisfied_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "CONSTRAINT_W", ")", ")", ")", "&&", "(", "(", "mode", "==", "QImode", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "%", "2", "==", "0", ")", "&&", "CONST_OK_FOR_K", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "+", "(", "GET_MODE_NUNITS", "(", "mode", ")", "*", "UNITS_PER_WORD", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

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

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_tls_symbol", "(", "rtx", "x", ")", "{", "enum", "tls_model", "tls_kind", "=", "tls_symbolic_operand_type", "(", "x", ")", ";", "switch", "(", "tls_kind", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "return", "TARGET_TLS_DESC", "?", "SYMBOL_SMALL_TLSDESC", ":", "SYMBOL_SMALL_TLSGD", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "return", "SYMBOL_SMALL_GOTTPREL", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "return", "SYMBOL_SMALL_TPREL", ";", "case", "TLS_MODEL_EMULATED", ":", "case", "TLS_MODEL_NONE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Classify", "a", "TLS", "symbol", "into", "one", "of", "the", "TLS", "kinds", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "<=", "(", "Subtarget", "->", "isMClass", "(", ")", "?", "32U", ":", "64U", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "ARM", "ARM", "32U", "64U" ]

[]

[ "<s>", "void", "scalar_chain", "::", "add_to_queue", "(", "unsigned", "insn_uid", ")", "{", "if", "(", "!", "bitmap_set_bit", "(", "queue", ",", "insn_uid", ")", ")", "return", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Adding insn %d into chain's #%d queue\\n\"", ",", "insn_uid", ",", "chain_id", ")", ";", "}", "</s>" ]

[ "Add", "instruction", "into", "chains", "'", "queue", "." ]

[ "i386", "\" Adding insn %d into chain's #%d queue\\n\"" ]

[]

[ "<s>", "virtual", "const", "Z80RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "static", "void", "cris_option_override", "(", "void", ")", "{", "if", "(", "cris_max_stackframe_str", ")", "{", "cris_max_stackframe", "=", "atoi", "(", "cris_max_stackframe_str", ")", ";", "if", "(", "cris_max_stackframe", "<", "0", "||", "cris_max_stackframe", ">", "0x20000000", ")", "internal_error", "(", "\"%<-max-stackframe=%d%> is not usable, \"", "\"not between 0 and %d\"", ",", "cris_max_stackframe", ",", "0x20000000", ")", ";", "}", "if", "(", "TARGET_SVINTO", "&&", "cris_cpu_version", "<", "CRIS_CPU_SVINTO", ")", "cris_cpu_version", "=", "CRIS_CPU_SVINTO", ";", "else", "if", "(", "TARGET_ETRAX4_ADD", "&&", "cris_cpu_version", "<", "CRIS_CPU_ETRAX4", ")", "cris_cpu_version", "=", "CRIS_CPU_ETRAX4", ";", "if", "(", "cris_cpu_str", ")", "{", "cris_cpu_version", "=", "(", "*", "cris_cpu_str", "==", "'v'", "?", "atoi", "(", "cris_cpu_str", "+", "1", ")", ":", "-", "1", ")", ";", "if", "(", "strcmp", "(", "\"etrax4\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "3", ";", "if", "(", "strcmp", "(", "\"svinto\"", ",", "cris_cpu_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "8", ";", "if", "(", "strcmp", "(", "\"ng\"", ",", "cris_cpu_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100lx\"", ",", "cris_cpu_str", ")", "==", "0", ")", "cris_cpu_version", "=", "10", ";", "if", "(", "cris_cpu_version", "<", "0", "||", "cris_cpu_version", ">", "10", ")", "error", "(", "\"unknown CRIS version specification in %<-march=%> or \"", "\"%<-mcpu=%> : %s\"", ",", "cris_cpu_str", ")", ";", "if", "(", "cris_cpu_version", ">=", "CRIS_CPU_ETRAX4", ")", "target_flags", "|=", "MASK_ETRAX4_ADD", ";", "if", "(", "cris_cpu_version", ">=", "CRIS_CPU_SVINTO", ")", "target_flags", "|=", "(", "MASK_SVINTO", "|", "MASK_ALIGN_BY_32", "|", "MASK_STACK_ALIGN", "|", "MASK_CONST_ALIGN", "|", "MASK_DATA_ALIGN", ")", ";", "}", "if", "(", "cris_tune_str", ")", "{", "int", "cris_tune", "=", "(", "*", "cris_tune_str", "==", "'v'", "?", "atoi", "(", "cris_tune_str", "+", "1", ")", ":", "-", "1", ")", ";", "if", "(", "strcmp", "(", "\"etrax4\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "3", ";", "if", "(", "strcmp", "(", "\"svinto\"", ",", "cris_tune_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "8", ";", "if", "(", "strcmp", "(", "\"ng\"", ",", "cris_tune_str", ")", "==", "0", "||", "strcmp", "(", "\"etrax100lx\"", ",", "cris_tune_str", ")", "==", "0", ")", "cris_tune", "=", "10", ";", "if", "(", "cris_tune", "<", "0", "||", "cris_tune", ">", "32", ")", "error", "(", "\"unknown CRIS cpu version specification in %<-mtune=%> : %s\"", ",", "cris_tune_str", ")", ";", "if", "(", "cris_tune", ">=", "CRIS_CPU_SVINTO", ")", "target_flags", "|=", "(", "MASK_STACK_ALIGN", "|", "MASK_CONST_ALIGN", "|", "MASK_DATA_ALIGN", "|", "MASK_ALIGN_BY_32", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "error", "(", "\"%<-fPIC%> and %<-fpic%> are not supported on this target\"", ")", ";", "flag_pic", "=", "0", ";", "}", "init_machine_status", "=", "cris_init_machine_status", ";", "}", "</s>" ]

[ "The", "TARGET_OPTION_OVERRIDE", "worker", ".", "As", "is", "the", "norm", ",", "this", "also", "parses", "-mfoo=bar", "type", "parameters", "." ]

[ "cris", "0", "0x20000000", "\"%<-max-stackframe=%d%> is not usable, \"", "\"not between 0 and %d\"", "0x20000000", "1", "1", "\"etrax4\"", "0", "3", "\"svinto\"", "0", "\"etrax100\"", "0", "8", "\"ng\"", "0", "\"etrax100lx\"", "0", "10", "0", "10", "\"unknown CRIS version specification in %<-march=%> or \"", "\"%<-mcpu=%> : %s\"", "1", "1", "\"etrax4\"", "0", "3", "\"svinto\"", "0", "\"etrax100\"", "0", "8", "\"ng\"", "0", "\"etrax100lx\"", "0", "10", "0", "32", "\"unknown CRIS cpu version specification in %<-mtune=%> : %s\"", "\"%<-fPIC%> and %<-fpic%> are not supported on this target\"", "0" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "bool", "NeedShadowCallStackProlog", "=", "false", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ",", "NeedShadowCallStackProlog", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "NeedShadowCallStackProlog", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "STRXpost", ")", ")", ".", "addReg", "(", "AArch64", "::", "X18", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ")", ".", "addReg", "(", "AArch64", "::", "X18", ")", ".", "addImm", "(", "8", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MBB", ".", "addLiveIn", "(", "AArch64", "::", "X18", ")", ";", "}", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPXi", ":", "AArch64", "::", "STRXui", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPDi", ":", "AArch64", "::", "STRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "printReg", "(", "Reg1", ",", "TRI", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "printReg", "(", "Reg2", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg1", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg2", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::STRXpost", "AArch64::X18", "AArch64::LR", "AArch64::X18", "8", "AArch64::X18", "AArch64::STPXi", "AArch64::STRXui", "AArch64::STPDi", "AArch64::STRDui", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "static", "void", "register_vector_type", "(", "vector_type_index", "type", ")", "{", "tree", "vectype", "=", "abi_vector_types", "[", "type", "]", ";", "tree", "id", "=", "get_identifier", "(", "vector_types", "[", "type", "]", ".", "acle_name", ")", ";", "tree", "decl", "=", "build_decl", "(", "input_location", ",", "TYPE_DECL", ",", "id", ",", "vectype", ")", ";", "decl", "=", "lang_hooks", ".", "decls", ".", "pushdecl", "(", "decl", ")", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "TYPE_DECL", "&&", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "&&", "TYPE_MAIN_VARIANT", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "vectype", ")", "vectype", "=", "TREE_TYPE", "(", "decl", ")", ";", "acle_vector_types", "[", "0", "]", "[", "type", "]", "=", "vectype", ";", "}", "</s>" ]

[ "Register", "vector", "type", "TYPE", "under", "its", "risv_vector.h", "name", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "bool", "isBranch", "(", "unsigned", "Opcode", ")", "{", "return", "Opcode", "==", "R600", "::", "BRANCH", "||", "Opcode", "==", "R600", "::", "BRANCH_COND_i32", "||", "Opcode", "==", "R600", "::", "BRANCH_COND_f32", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "is", "a", "conditional", ",", "unconditional", ",", "or", "indirect", "branch", "." ]

[ "AMDGPU", "R600::BRANCH", "R600::BRANCH_COND_i32", "R600::BRANCH_COND_f32" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "TriCore", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_leg_mov_hi16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_leg_mov_lo16_pcrel\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_call\"", ",", "0", ",", "24", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "}", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore::NumTargetFixupKinds", "\"fixup_leg_mov_hi16_pcrel\"", "0", "32", "\"fixup_leg_mov_lo16_pcrel\"", "0", "32", "\"fixup_call\"", "0", "24", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "Directive", "=", "Subtarget", ".", "getCPUDirective", "(", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "Directive", ")", "{", "default", ":", "Opcode", "=", "PPC", "::", "NOP", ";", "break", ";", "case", "PPC", "::", "DIR_PWR6", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR6", ";", "break", ";", "case", "PPC", "::", "DIR_PWR7", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "DIR_PWR8", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "DIR_PWR9", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "}", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "PowerPC", "PPC", "PPC::NOP", "PPC::DIR_PWR6", "PPC::NOP_GT_PWR6", "PPC::DIR_PWR7", "PPC::NOP_GT_PWR7", "PPC::DIR_PWR8", "PPC::NOP_GT_PWR7", "PPC::DIR_PWR9", "PPC::NOP_GT_PWR7" ]

[]

[ "<s>", "DecodeStatus", "AArch64Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "Fail", ";", "Size", "=", "4", ";", "uint32_t", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "const", "uint8_t", "*", "Tables", "[", "]", "=", "{", "DecoderTable32", ",", "DecoderTableFallback32", "}", ";", "for", "(", "auto", "Table", ":", "Tables", ")", "{", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "Table", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDR_ZA", ":", "case", "AArch64", "::", "STR_ZA", ":", "{", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "AArch64", "::", "ZA", ")", ")", ";", "const", "MCOperand", "&", "Imm4Op", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "assert", "(", "Imm4Op", ".", "isImm", "(", ")", "&&", "\"Unexpected operand type!\"", ")", ";", "MI", ".", "addOperand", "(", "Imm4Op", ")", ";", "break", ";", "}", "case", "AArch64", "::", "LD1_MXIPXX_H_B", ":", "case", "AArch64", "::", "LD1_MXIPXX_V_B", ":", "case", "AArch64", "::", "ST1_MXIPXX_H_B", ":", "case", "AArch64", "::", "ST1_MXIPXX_V_B", ":", "case", "AArch64", "::", "INSERT_MXIPZ_H_B", ":", "case", "AArch64", "::", "INSERT_MXIPZ_V_B", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "AArch64", "::", "ZAB0", ")", ")", ";", "break", ";", "case", "AArch64", "::", "EXTRACT_ZPMXI_H_B", ":", "case", "AArch64", "::", "EXTRACT_ZPMXI_V_B", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "2", ",", "MCOperand", "::", "createReg", "(", "AArch64", "::", "ZAB0", ")", ")", ";", "break", ";", "case", "AArch64", "::", "LD1_MXIPXX_H_Q", ":", "case", "AArch64", "::", "LD1_MXIPXX_V_Q", ":", "case", "AArch64", "::", "ST1_MXIPXX_H_Q", ":", "case", "AArch64", "::", "ST1_MXIPXX_V_Q", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "2", ",", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "break", ";", "case", "AArch64", "::", "INSERT_MXIPZ_H_Q", ":", "case", "AArch64", "::", "INSERT_MXIPZ_V_Q", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "2", ",", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "break", ";", "case", "AArch64", "::", "EXTRACT_ZPMXI_H_Q", ":", "case", "AArch64", "::", "EXTRACT_ZPMXI_V_Q", ":", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "break", ";", "case", "AArch64", "::", "SMOVvi8to32_idx0", ":", "case", "AArch64", "::", "SMOVvi8to64_idx0", ":", "case", "AArch64", "::", "SMOVvi16to32_idx0", ":", "case", "AArch64", "::", "SMOVvi16to64_idx0", ":", "case", "AArch64", "::", "SMOVvi32to64_idx0", ":", "case", "AArch64", "::", "UMOVvi8_idx0", ":", "case", "AArch64", "::", "UMOVvi16_idx0", ":", "case", "AArch64", "::", "UMOVvi32_idx0", ":", "case", "AArch64", "::", "UMOVvi64_idx0", ":", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "break", ";", "}", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "4", "4", "3", "24", "2", "16", "1", "8", "0", "0", "AArch64::LDR_ZA", "AArch64::STR_ZA", "AArch64::ZA", "2", "\"Unexpected operand type!\"", "AArch64::LD1_MXIPXX_H_B", "AArch64::LD1_MXIPXX_V_B", "AArch64::ST1_MXIPXX_H_B", "AArch64::ST1_MXIPXX_V_B", "AArch64::INSERT_MXIPZ_H_B", "AArch64::INSERT_MXIPZ_V_B", "AArch64::ZAB0", "AArch64::EXTRACT_ZPMXI_H_B", "AArch64::EXTRACT_ZPMXI_V_B", "2", "AArch64::ZAB0", "AArch64::LD1_MXIPXX_H_Q", "AArch64::LD1_MXIPXX_V_Q", "AArch64::ST1_MXIPXX_H_Q", "AArch64::ST1_MXIPXX_V_Q", "2", "0", "AArch64::INSERT_MXIPZ_H_Q", "AArch64::INSERT_MXIPZ_V_Q", "2", "0", "AArch64::EXTRACT_ZPMXI_H_Q", "AArch64::EXTRACT_ZPMXI_V_Q", "0", "AArch64::SMOVvi8to32_idx0", "AArch64::SMOVvi8to64_idx0", "AArch64::SMOVvi16to32_idx0", "AArch64::SMOVvi16to64_idx0", "AArch64::SMOVvi32to64_idx0", "AArch64::UMOVvi8_idx0", "AArch64::UMOVvi16_idx0", "AArch64::UMOVvi32_idx0", "AArch64::UMOVvi64_idx0", "0" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "if", "(", "ZFI", "->", "getLowSavedGPR", "(", ")", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "iq2000_select_section", "(", "tree", "decl", ",", "int", "reloc", "ATTRIBUTE_UNUSED", ",", "unsigned", "HOST_WIDE_INT", "align", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_EMBEDDED_DATA", ")", "{", "if", "(", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "DECL_INITIAL", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "||", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "readonly_data_section", "(", ")", ";", "else", "data_section", "(", ")", ";", "}", "else", "{", "if", "(", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "DECL_INITIAL", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "||", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "readonly_data_section", "(", ")", ";", "else", "data_section", "(", ")", ";", "}", "}", "</s>" ]

[ "Choose", "the", "section", "to", "use", "for", "DECL", ".", "RELOC", "is", "true", "if", "its", "value", "contains", "any", "relocatable", "expression", ".", "Some", "of", "the", "logic", "used", "here", "needs", "to", "be", "replicated", "in", "ENCODE_SECTION_INFO", "in", "iq2000.h", "so", "that", "references", "to", "these", "symbols", "are", "done", "correctly", "." ]

[ "iq2000" ]

[]

[ "<s>", "void", "FISCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createFISCDelaySlotFillerPass", "(", "getFISCTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC", "FISC" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "X86ISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "return", "HasRet", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "X86", "X86", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "ISD::FP_EXTEND", "X86ISD::RET_FLAG" ]

[]

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

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

[ "SNES", "SNES::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "mem", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "rtx_insn", "*", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "mem", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>" ]

[ "Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "." ]

[ "alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1" ]

[]

[ "<s>", "void", "mmix_asm_output_ascii", "(", "FILE", "*", "stream", ",", "const", "char", "*", "string", ",", "int", "length", ")", "{", "while", "(", "length", ">", "0", ")", "{", "int", "chunk_size", "=", "length", ">", "60", "?", "60", ":", "length", ";", "fprintf", "(", "stream", ",", "\"\\tBYTE \"", ")", ";", "mmix_output_quoted_string", "(", "stream", ",", "string", ",", "chunk_size", ")", ";", "string", "+=", "chunk_size", ";", "length", "-=", "chunk_size", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

[ "ASM_OUTPUT_ASCII", "." ]

[ "mmix", "0", "60", "60", "\"\\tBYTE \"", "\"\\n\"" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "X86" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_save_reg_mask", "(", "void", ")", "{", "unsigned", "int", "save_reg_mask", "=", "0", ";", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "(", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ")", "|", "(", "1", "<<", "IP_REGNUM", ")", "|", "(", "1", "<<", "LR_REGNUM", ")", "|", "(", "1", "<<", "PC_REGNUM", ")", ";", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "return", "save_reg_mask", ";", "save_reg_mask", "|=", "arm_compute_save_reg0_reg12_mask", "(", ")", ";", "if", "(", "regs_ever_live", "[", "LR_REGNUM", "]", "||", "(", "save_reg_mask", "&&", "optimize_size", "&&", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_NORMAL", "&&", "!", "current_function_calls_eh_return", ")", ")", "save_reg_mask", "|=", "1", "<<", "LR_REGNUM", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "save_reg_mask", "&=", "~", "(", "1", "<<", "LR_REGNUM", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "(", "(", "bit_count", "(", "save_reg_mask", ")", "+", "ARM_NUM_INTS", "(", "current_function_pretend_args_size", ")", ")", "%", "2", ")", "!=", "0", ")", "{", "unsigned", "int", "reg", ";", "for", "(", "reg", "=", "4", ";", "reg", "<=", "12", ";", "reg", "++", ")", "if", "(", "(", "save_reg_mask", "&", "(", "1", "<<", "reg", ")", ")", "==", "0", ")", "break", ";", "if", "(", "reg", "<=", "12", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "else", "{", "cfun", "->", "machine", "->", "sibcall_blocked", "=", "1", ";", "save_reg_mask", "|=", "(", "1", "<<", "3", ")", ";", "}", "}", "return", "save_reg_mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", ".", "This", "is", "used", "by", "arm_get_frame_offsets", ",", "which", "may", "add", "extra", "registers", "." ]

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

[]

[ "<s>", "rtx", "mn10300_legitimize_pic_address", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx", "x", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "orig", ")", "||", "!", "MN10300_GLOBAL_P", "(", "orig", ")", ")", ")", ")", "{", "if", "(", "reg", "==", "NULL", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "orig", ")", ",", "UNSPEC_GOTOFF", ")", ";", "x", "=", "gen_rtx_CONST", "(", "SImode", ",", "x", ")", ";", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "x", "=", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "pic_offset_table_rtx", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "reg", "==", "NULL", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "orig", ")", ",", "UNSPEC_GOT", ")", ";", "x", "=", "gen_rtx_CONST", "(", "SImode", ",", "x", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "pic_offset_table_rtx", ",", "x", ")", ";", "x", "=", "gen_const_mem", "(", "SImode", ",", "x", ")", ";", "x", "=", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "}", "else", "return", "orig", ";", "set_unique_reg_note", "(", "x", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Convert", "a", "non-PIC", "address", "in", "`", "orig", "'", "to", "a", "PIC", "address", "using", "@", "GOT", "or", "@", "GOTOFF", "in", "`", "reg", "'", "." ]

[ "mn10300", "1", "1" ]

[]

[ "<s>", "void", "reserveBlocks", "(", "unsigned", "Size", ")", "{", "Blocks", ".", "reserve", "(", "Size", ")", ";", "}", "</s>" ]

[ "interface", "to", "do", "reserve", "(", ")", "for", "Blocks" ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreRewrite", "(", ")", "{", "addPass", "(", "createX86TileConfigPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "addPreRewrite", "-", "Add", "passes", "to", "the", "optimized", "register", "allocation", "pipeline", "after", "register", "allocation", "is", "complete", ",", "but", "before", "virtual", "registers", "are", "rewritten", "to", "physical", "registers", "." ]

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

[]

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

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Execution Dependency Fix\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Execution Dependency Fix\"" ]

[]

[ "<s>", "bool", "MipsModuleDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"In MipsModuleDAGToDAGISel::runMachineFunction\\n\"", ")", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "MipsTargetMachine", ">", "(", ")", ";", "TM", ".", "resetSubtarget", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"In MipsModuleDAGToDAGISel::runMachineFunction\\n\"", "Mips" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "bool", "Fast", ";", "if", "(", "Size", ">=", "16", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "v2f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "v2f64", ";", "}", "else", "if", "(", "Size", ">=", "8", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "ARM", "ARM", "16", "16", "MVT::v2f64", "0", "1", "MVT::v2f64", "8", "8", "MVT::f64", "0", "1", "MVT::f64", "MVT::Other" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "unsigned", "Kind", ";", "unsigned", "Opcode", ";", "unsigned", "ErrorInfo", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "std", "::", "string", ">", ",", "4", ">", "MapAndConstraints", ";", "bool", "Error", "=", "MatchInstruction", "(", "IDLoc", ",", "Operands", ",", "Out", ",", "Kind", ",", "Opcode", ",", "MapAndConstraints", ",", "ErrorInfo", ")", ";", "return", "Error", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

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

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "const", "MCSymbolRefExpr", "*", "A", "=", "Target", ".", "getSymA", "(", ")", ";", "const", "MCSymbol", "*", "Sym", "=", "A", "?", "&", "A", "->", "getSymbol", "(", ")", ":", "nullptr", ";", "const", "unsigned", "FixupKind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", "==", "ARM", "::", "fixup_arm_thumb_bl", ")", "{", "assert", "(", "Sym", "&&", "\"How did we resolve this?\"", ")", ";", "if", "(", "Sym", "->", "isExternal", "(", ")", ")", "return", "true", ";", "}", "if", "(", "Sym", "&&", "Sym", "->", "isELF", "(", ")", ")", "{", "unsigned", "Type", "=", "cast", "<", "MCSymbolELF", ">", "(", "Sym", ")", "->", "getType", "(", ")", ";", "if", "(", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", ")", "{", "if", "(", "Asm", ".", "isThumbFunc", "(", "Sym", ")", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_uncondbranch", ")", ")", "return", "true", ";", "if", "(", "!", "Asm", ".", "isThumbFunc", "(", "Sym", ")", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_br", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_bl", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_condbranch", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_uncondbranch", ")", ")", "return", "true", ";", "}", "}", "if", "(", "A", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_thumb_blx", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_blx", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_uncondbl", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_condbl", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "ARM", "ARM", "ARM::fixup_arm_thumb_bl", "\"How did we resolve this?\"", "ARM::fixup_arm_uncondbranch", "ARM::fixup_arm_thumb_br", "ARM::fixup_arm_thumb_bl", "ARM::fixup_t2_condbranch", "ARM::fixup_t2_uncondbranch", "ARM::fixup_arm_thumb_blx", "ARM::fixup_arm_blx", "ARM::fixup_arm_uncondbl", "ARM::fixup_arm_condbl" ]

[]

[ "<s>", "void", "MSP430AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MSP430MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "MCInst", "MCBundleInst", ";", "const", "MachineInstr", "*", "BundledInst", "=", "I", ";", "MCInstLowering", ".", "lower", "(", "BundledInst", ",", "MCBundleInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCBundleInst", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "const", "MCRegisterInfo", "*", "getMRI", "(", ")", "const", "{", "return", "const_cast", "<", "AMDGPUAsmParser", "*", ">", "(", "this", ")", "->", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "Getter", "for", "MRI", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "arm_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "TARGET_NEON", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode2", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisablePacketizer", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "Begin", "=", "MB", ".", "begin", "(", ")", ",", "End", "=", "MB", ".", "end", "(", ")", ";", "while", "(", "Begin", "!=", "End", ")", "{", "MachineBasicBlock", "::", "iterator", "RB", "=", "Begin", ";", "while", "(", "RB", "!=", "End", "&&", "HII", "->", "isSchedulingBoundary", "(", "RB", ",", "&", "MB", ",", "MF", ")", ")", "++", "RB", ";", "MachineBasicBlock", "::", "iterator", "RE", "=", "RB", ";", "while", "(", "RE", "!=", "End", "&&", "!", "HII", "->", "isSchedulingBoundary", "(", "RE", ",", "&", "MB", ",", "MF", ")", ")", "++", "RE", ";", "if", "(", "RE", "!=", "End", ")", "++", "RE", ";", "if", "(", "RB", "!=", "End", ")", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "RB", ",", "RE", ")", ";", "Begin", "=", "RE", ";", "}", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

[ "<s>", "static", "void", "frv_start_packet_block", "(", "void", ")", "{", "state_reset", "(", "frv_packet", ".", "dfa_state", ")", ";", "frv_start_packet", "(", ")", ";", "}", "</s>" ]

[ "Likewise", "for", "the", "start", "of", "a", "new", "basic", "block", "." ]

[ "frv" ]

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "const", "char", "*", "p", ";", "p", "=", "\"e-p:32:32:32\"", ";", "return", "std", "::", "string", "(", "p", ")", ";", "}", "</s>" ]

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

[ "ARCompact", "\"e-p:32:32:32\"" ]

[]

[ "<s>", "void", "visium_expand_copysign", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "mask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "0x7fffffff", ")", ")", ";", "rtx", "x", ";", "gcc_assert", "(", "mode", "==", "SFmode", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op0", ")", ")", ")", "op0", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op0", ",", "mode", ")", ";", "if", "(", "op0", "!=", "CONST0_RTX", "(", "mode", ")", ")", "{", "long", "l", ";", "REAL_VALUE_TYPE", "rv", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rv", ",", "op0", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "rv", ",", "l", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "l", ",", "SImode", ")", ")", ")", ";", "}", "}", "else", "{", "op0", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op0", ")", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op0", ",", "mask", ")", ")", ";", "}", "mask", "=", "force_reg", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ";", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op1", ")", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op1", ",", "mask", ")", ")", ";", "if", "(", "op0", "==", "CONST0_RTX", "(", "SFmode", ")", ")", "x", "=", "op1", ";", "else", "x", "=", "force_reg", "(", "SImode", ",", "gen_rtx_IOR", "(", "SImode", ",", "op0", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_lowpart", "(", "SFmode", ",", "x", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "copysign", "of", "OPERANDS", "in", "MODE", "." ]

[ "visium", "0", "1", "2", "0x7fffffff" ]

[]

[ "<s>", "void", "sh_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__sh__\"", ")", ";", "builtin_assert", "(", "\"cpu=sh\"", ")", ";", "builtin_assert", "(", "\"machine=sh\"", ")", ";", "switch", "(", "(", "int", ")", "sh_cpu", ")", "{", "case", "PROCESSOR_SH1", ":", "builtin_define", "(", "\"__sh1__\"", ")", ";", "builtin_define", "(", "\"__SH1__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2", ":", "builtin_define", "(", "\"__sh2__\"", ")", ";", "builtin_define", "(", "\"__SH2__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2E", ":", "builtin_define", "(", "\"__SH2E__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH2A", ":", "builtin_define", "(", "\"__SH2A__\"", ")", ";", "if", "(", "TARGET_SH2A_DOUBLE", ")", "builtin_define", "(", "TARGET_FPU_SINGLE", "?", "\"__SH2A_SINGLE__\"", ":", "\"__SH2A_DOUBLE__\"", ")", ";", "else", "builtin_define", "(", "TARGET_FPU_ANY", "?", "\"__SH2A_SINGLE_ONLY__\"", ":", "\"__SH2A_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH3", ":", "builtin_define", "(", "\"__sh3__\"", ")", ";", "builtin_define", "(", "\"__SH3__\"", ")", ";", "if", "(", "TARGET_HARD_SH4", ")", "builtin_define", "(", "\"__SH4_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH3E", ":", "builtin_define", "(", "TARGET_HARD_SH4", "?", "\"__SH4_SINGLE_ONLY__\"", ":", "\"__SH3E__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH4", ":", "builtin_define", "(", "TARGET_FPU_SINGLE", "?", "\"__SH4_SINGLE__\"", ":", "\"__SH4__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH4A", ":", "\\", "builtin_define", "(", "\"__SH4A__\"", ")", ";", "builtin_define", "(", "TARGET_SH4", "?", "(", "TARGET_FPU_SINGLE", "?", "\"__SH4_SINGLE__\"", ":", "\"__SH4__\"", ")", ":", "TARGET_FPU_ANY", "?", "\"__SH4_SINGLE_ONLY__\"", ":", "\"__SH4_NOFPU__\"", ")", ";", "break", ";", "case", "PROCESSOR_SH5", ":", "{", "builtin_define_with_value", "(", "\"__SH5__\"", ",", "TARGET_SHMEDIA64", "?", "\"64\"", ":", "\"32\"", ",", "0", ")", ";", "builtin_define_with_value", "(", "\"__SHMEDIA__\"", ",", "TARGET_SHMEDIA", "?", "\"1\"", ":", "\"0\"", ",", "0", ")", ";", "if", "(", "!", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "\"__SH4_NOFPU__\"", ")", ";", "}", "}", "if", "(", "TARGET_FPU_ANY", ")", "builtin_define", "(", "\"__SH_FPU_ANY__\"", ")", ";", "if", "(", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "\"__SH_FPU_DOUBLE__\"", ")", ";", "if", "(", "TARGET_HITACHI", ")", "builtin_define", "(", "\"__HITACHI__\"", ")", ";", "if", "(", "TARGET_FMOVD", ")", "builtin_define", "(", "\"__FMOVD_ENABLED__\"", ")", ";", "builtin_define", "(", "TARGET_LITTLE_ENDIAN", "?", "\"__LITTLE_ENDIAN__\"", ":", "\"__BIG_ENDIAN__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__SH_ATOMIC_MODEL_%s__\"", ",", "selected_atomic_model", "(", ")", ".", "cdef_name", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_CPU_CPP_BUILTINS", "macro" ]

[ "sh", "\"__sh__\"", "\"cpu=sh\"", "\"machine=sh\"", "\"__sh1__\"", "\"__SH1__\"", "\"__sh2__\"", "\"__SH2__\"", "\"__SH2E__\"", "\"__SH2A__\"", "\"__SH2A_SINGLE__\"", "\"__SH2A_DOUBLE__\"", "\"__SH2A_SINGLE_ONLY__\"", "\"__SH2A_NOFPU__\"", "\"__sh3__\"", "\"__SH3__\"", "\"__SH4_NOFPU__\"", "\"__SH4_SINGLE_ONLY__\"", "\"__SH3E__\"", "\"__SH4_SINGLE__\"", "\"__SH4__\"", "\"__SH4A__\"", "\"__SH4_SINGLE__\"", "\"__SH4__\"", "\"__SH4_SINGLE_ONLY__\"", "\"__SH4_NOFPU__\"", "\"__SH5__\"", "\"64\"", "\"32\"", "0", "\"__SHMEDIA__\"", "\"1\"", "\"0\"", "0", "\"__SH4_NOFPU__\"", "\"__SH_FPU_ANY__\"", "\"__SH_FPU_DOUBLE__\"", "\"__HITACHI__\"", "\"__FMOVD_ENABLED__\"", "\"__LITTLE_ENDIAN__\"", "\"__BIG_ENDIAN__\"", "\"__SH_ATOMIC_MODEL_%s__\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "LEGMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "LEG", "LEG" ]

[]

[ "<s>", "bool", "CSKYInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "getOppositeBranchOpc", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "2", "\"Invalid branch condition!\"", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "hasAndNot", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "hasAndNotCompare", "(", "Y", ")", ";", "if", "(", "!", "Subtarget", ".", "hasSSE1", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", "<", "128", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "v4i32", ")", "return", "true", ";", "return", "Subtarget", ".", "hasSSE2", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bitwise", "and-not", "operation", ":", "X", "=", "~A", "&", "B", "This", "can", "be", "used", "to", "simplify", "select", "or", "other", "instructions", "." ]

[ "X86", "X86", "128", "MVT::v4i32" ]

[]

[ "<s>", "int", "rl78_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "s", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "s", "<", "1", ")", "return", "0", ";", "if", "(", "regno", "==", "23", "||", "regno", "==", "ES_REG", "||", "regno", "==", "CS_REG", ")", "return", "0", ";", "if", "(", "regno", "==", "FP_REG", "&&", "s", "==", "2", ")", "return", "1", ";", "if", "(", "regno", "<", "SP_REG", ")", "{", "if", "(", "s", ">", "1", "&&", "(", "regno", "%", "2", ")", ")", "return", "0", ";", "return", "1", ";", "}", "if", "(", "s", "==", "CC_REGNUM", ")", "return", "(", "mode", "==", "BImode", ")", ";", "if", "(", "s", "==", "register_sizes", "[", "regno", "]", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_MODE_OK", "." ]

[ "rl78", "1", "0", "23", "0", "2", "1", "1", "2", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SystemZAddressingMode", "::", "AddrForm", "Form", ";", "SystemZAddressingMode", "::", "DispRange", "DispRange", ";", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_S", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_T", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "}", "if", "(", "selectBDXAddr", "(", "Form", ",", "DispRange", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "{", "const", "TargetRegisterClass", "*", "TRC", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "*", "MF", ")", ";", "SDLoc", "DL", "(", "Base", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetFrameIndex", "&&", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Base", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Base", ".", "getValueType", "(", ")", ",", "Base", ",", "RC", ")", ",", "0", ")", ";", "}", "if", "(", "Index", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Index", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Index", ".", "getValueType", "(", ")", ",", "Index", ",", "RC", ")", ",", "0", ")", ";", "}", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZAddressingMode::AddrForm", "SystemZAddressingMode::DispRange", "\"Unexpected asm memory constraint\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp20Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp20Only", "MVT::i32", "ISD::TargetFrameIndex", "ISD::Register", "0", "ISD::Register", "0" ]

[]

[ "<s>", "SDValue", "GBZ80TargetLowering", "::", "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", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "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", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "GBISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "GBISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "MCSymbol", "*", "KudeyarMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "Kudeyar", "Kudeyar", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "cris_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", ",", "vec", "<", "rtx", ">", "&", "inputs", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "CRIS_CC0_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CRIS_CC0_REGNUM", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "constraints", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "strchr", "(", "constraints", "[", "i", "]", ",", "'h'", ")", "!=", "NULL", ")", "return", "NULL", ";", "rtx", "mof_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "CRIS_MOF_REGNUM", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "outputs", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "reg_overlap_mentioned_p", "(", "mof_reg", ",", "outputs", "[", "i", "]", ")", ")", "return", "NULL", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "inputs", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "reg_overlap_mentioned_p", "(", "mof_reg", ",", "inputs", "[", "i", "]", ")", ")", "return", "NULL", ";", "clobbers", ".", "safe_push", "(", "mof_reg", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CRIS_MOF_REGNUM", ")", ";", "return", "NULL", ";", "}", "</s>" ]

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

[ "cris", "0", "0", "0" ]

[]

[ "<s>", "bool", "SNESDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SNESSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES" ]

[]

[ "<s>", "bool", "ARM64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Count", "=", "CSI", ".", "size", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "unsigned", "Reg1", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ";", "assert", "(", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", "+", "1", "==", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", "&&", "\"Out of order callee saved regs!\"", ")", ";", "unsigned", "LdrOpc", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "assert", "(", "(", "i", "&", "1", ")", "==", "0", "&&", "\"Odd index for callee-saved reg spill!\"", ")", ";", "if", "(", "ARM64", "::", "GPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "ARM64", "::", "GPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected GPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "Count", "-", "2", ")", "LdrOpc", "=", "ARM64", "::", "LDPXpost", ";", "else", "LdrOpc", "=", "ARM64", "::", "LDPXi", ";", "}", "else", "if", "(", "ARM64", "::", "FPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "ARM64", "::", "FPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected FPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "Count", "-", "2", ")", "LdrOpc", "=", "ARM64", "::", "LDPDpost", ";", "else", "LdrOpc", "=", "ARM64", "::", "LDPDi", ";", "}", "else", "llvm_unreachable", "(", "\"Unexpected callee saved register!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", "<<", "\") -> fi#(\"", "<<", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", "<<", "\", \"", "<<", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "(", "i", "==", "Count", "-", "2", ")", "?", "Count", ":", "Count", "-", "i", "-", "2", ";", "assert", "(", "(", "Offset", ">=", "-", "64", "&&", "Offset", "<=", "63", ")", "&&", "\"Offset out of bounds for LDP immediate\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "ARM64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "0", "2", "1", "1", "1", "\"Out of order callee saved regs!\"", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "1", "0", "\"Odd index for callee-saved reg spill!\"", "ARM64::GPR64RegClass", "ARM64::GPR64RegClass", "\"Expected GPR64 callee-saved register pair!\"", "2", "ARM64::LDPXpost", "ARM64::LDPXi", "ARM64::FPR64RegClass", "ARM64::FPR64RegClass", "\"Expected FPR64 callee-saved register pair!\"", "2", "ARM64::LDPDpost", "ARM64::LDPDi", "\"Unexpected callee saved register!\"", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "2", "2", "64", "63", "\"Offset out of bounds for LDP immediate\"", "ARM64::SP" ]

[]

[ "<s>", "void", "expand_move", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "emit_pic_move", "(", "operands", ",", "mode", ")", ";", "else", "if", "(", "(", "reload_in_progress", "|", "reload_completed", ")", "==", "0", "&&", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "operands", "[", "1", "]", ")", "!=", "REG", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Expand", "a", "move", "operation", "in", "mode", "MODE", ".", "The", "operands", "are", "in", "OPERANDS", "." ]

[ "bfin", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "arm_load_pic_register", "(", "unsigned", "long", "saved_regs", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "l1", ",", "labelno", ",", "pic_tmp", ",", "pic_tmp2", ",", "pic_rtx", ";", "rtx", "global_offset_table", ";", "if", "(", "current_function_uses_pic_offset_table", "==", "0", "||", "TARGET_SINGLE_PIC_BASE", ")", "return", ";", "gcc_assert", "(", "flag_pic", ")", ";", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "l1", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "l1", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "l1", ")", ";", "global_offset_table", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "pic_tmp", "=", "plus_constant", "(", "l1", ",", "TARGET_ARM", "?", "8", ":", "4", ")", ";", "if", "(", "GOT_PCREL", ")", "pic_tmp2", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "global_offset_table", ",", "pc_rtx", ")", ")", ";", "else", "pic_tmp2", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "global_offset_table", ")", ";", "pic_rtx", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "pic_tmp2", ",", "pic_tmp", ")", ")", ";", "if", "(", "TARGET_ARM", ")", "{", "emit_insn", "(", "gen_pic_load_addr_arm", "(", "pic_offset_table_rtx", ",", "pic_rtx", ")", ")", ";", "emit_insn", "(", "gen_pic_add_dot_plus_eight", "(", "pic_offset_table_rtx", ",", "pic_offset_table_rtx", ",", "labelno", ")", ")", ";", "}", "else", "{", "if", "(", "REGNO", "(", "pic_offset_table_rtx", ")", ">", "LAST_LO_REGNUM", ")", "{", "pic_tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "thumb_find_work_register", "(", "saved_regs", ")", ")", ";", "emit_insn", "(", "gen_pic_load_addr_thumb", "(", "pic_tmp", ",", "pic_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "pic_offset_table_rtx", ",", "pic_tmp", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_pic_load_addr_thumb", "(", "pic_offset_table_rtx", ",", "pic_rtx", ")", ")", ";", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "pic_offset_table_rtx", ",", "pic_offset_table_rtx", ",", "labelno", ")", ")", ";", "}", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "pic_offset_table_rtx", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "the", "PIC", "register", ".", "In", "thumb", "mode", "SCRATCH", "is", "a", "low", "register", "." ]

[ "arm", "0", "1", "\"_GLOBAL_OFFSET_TABLE_\"", "8", "4" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "ret", "=", "rs6000_rtx_costs", "(", "x", ",", "mode", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_rtx_costs, return = %s, mode = %s, outer_code = %s, \"", "\"opno = %d, total = %d, speed = %s, x:\\n\"", ",", "ret", "?", "\"complete\"", ":", "\"scan inner\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "GET_RTX_NAME", "(", "outer_code", ")", ",", "opno", ",", "*", "total", ",", "speed", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "form", "of", "r6000_rtx_costs", "that", "is", "selected", "if", "-mdebug=cost", "." ]

[ "powerpcspe", "\"\\nrs6000_rtx_costs, return = %s, mode = %s, outer_code = %s, \"", "\"opno = %d, total = %d, speed = %s, x:\\n\"", "\"complete\"", "\"scan inner\"", "\"true\"", "\"false\"" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "RISCV", "::", "GPRRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "RISCV", "::", "SW", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::SW", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "TM", ".", "getTargetCPU", "(", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "NTM", ")", ";", "if", "(", "M", ".", "alias_size", "(", ")", ")", "{", "report_fatal_error", "(", "\"Module has aliases, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_ctors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_dtors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "emitHeader", "(", "M", ",", "OS1", ",", "STI", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "GlobalsEmitted", "=", "false", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "\"Module has aliases, which NVPTX does not support.\"", "\"llvm.global_ctors\"", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", "\"llvm.global_dtors\"", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "mcore_unique_section", "(", "tree", "decl", ",", "int", "reloc", "ATTRIBUTE_UNUSED", ")", "{", "int", "len", ";", "const", "char", "*", "name", ";", "char", "*", "string", ";", "const", "char", "*", "prefix", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "prefix", "=", "\".text$\"", ";", "else", "if", "(", "decl_readonly_section", "(", "decl", ",", "0", ")", ")", "prefix", "=", "\".rdata$\"", ";", "else", "prefix", "=", "\".data$\"", ";", "len", "=", "strlen", "(", "name", ")", "+", "strlen", "(", "prefix", ")", ";", "string", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "1", ")", ";", "sprintf", "(", "string", ",", "\"%s%s\"", ",", "prefix", ",", "name", ")", ";", "set_decl_section_name", "(", "decl", ",", "string", ")", ";", "}", "</s>" ]

[ "Cover", "function", "for", "UNIQUE_SECTION", "." ]

[ "mcore", "\".text$\"", "0", "\".rdata$\"", "\".data$\"", "1", "\"%s%s\"" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Local", "=", "MF", ".", "getFunction", "(", ")", "->", "hasLocalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Local", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "*", "ExtraCode", "==", "'n'", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "OS", "<<", "-", "int64_t", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "SystemZMCInstLower", "Lower", "(", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCOperand", "MO", "(", "Lower", ".", "lowerOperand", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ")", ")", ";", "SystemZInstPrinter", "::", "printOperand", "(", "MO", ",", "MAI", ",", "OS", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "loongarch_conditional_register_usage", "(", "void", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "accessible_reg_set", "&=", "~", "(", "reg_class_contents", "[", "FP_REGS", "]", "|", "reg_class_contents", "[", "FCC_REGS", "]", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "AArch64Subtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getRegBankInfo", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "AArch64", "AArch64", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "bool", "SILowerControlFlowPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "HaveKill", "=", "false", ";", "bool", "NeedM0", "=", "false", ";", "bool", "NeedWQM", "=", "false", ";", "unsigned", "Depth", "=", "0", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "TII", "->", "isDS", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "NeedM0", "=", "true", ";", "NeedWQM", "=", "true", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "++", "Depth", ";", "If", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "Else", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "Break", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "IfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "ElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "++", "Depth", ";", "Loop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "--", "Depth", "==", "0", "&&", "HaveKill", ")", "{", "SkipIfDead", "(", "MI", ")", ";", "HaveKill", "=", "false", ";", "}", "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "if", "(", "Depth", "==", "0", ")", "SkipIfDead", "(", "MI", ")", ";", "else", "HaveKill", "=", "true", ";", "Kill", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_SRC", ":", "IndirectSrc", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V1", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "IndirectDst", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "V_INTERP_P1_F32", ":", "case", "AMDGPU", "::", "V_INTERP_P2_F32", ":", "case", "AMDGPU", "::", "V_INTERP_MOV_F32", ":", "NeedWQM", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "NeedM0", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "InitM0ForLDS", "(", "MBB", ".", "getFirstNonPHI", "(", ")", ")", ";", "}", "if", "(", "NeedWQM", "&&", "MFI", "->", "ShaderType", "==", "ShaderType", "::", "PIXEL", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "getFirstNonPHI", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "SI", "SI", "0", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "0", "SI", "0", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "unsigned", "Z80InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", "&&", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "&&", "isFrameOperand", "(", "MI", ",", "1", ",", "FrameIndex", ")", ")", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Z80", "Z80", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR32RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR32RegClass", ")", "Opc", "=", "SystemZ", "::", "MOV32mr", ";", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP32RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV32mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64PRegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64Pmr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR128RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV128mr", ";", "}", "else", "llvm_unreachable", "(", "\"Unsupported regclass to store\"", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "SystemZ::GR32RegClass", "SystemZ::ADDR32RegClass", "SystemZ::MOV32mr", "SystemZ::GR64RegClass", "SystemZ::ADDR64RegClass", "SystemZ::MOV64mr", "SystemZ::FP32RegClass", "SystemZ::FMOV32mr", "SystemZ::FP64RegClass", "SystemZ::FMOV64mr", "SystemZ::GR64PRegClass", "SystemZ::MOV64Pmr", "SystemZ::GR128RegClass", "SystemZ::MOV128mr", "\"Unsupported regclass to store\"" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "nvvm_atomic_load_add_f32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "f32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "case", "Intrinsic", "::", "nvvm_atomic_load_inc_32", ":", "case", "Intrinsic", "::", "nvvm_atomic_load_dec_32", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "case", "Intrinsic", "::", "nvvm_ldu_global_i", ":", "case", "Intrinsic", "::", "nvvm_ldu_global_f", ":", "case", "Intrinsic", "::", "nvvm_ldu_global_p", ":", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "if", "(", "Intrinsic", "==", "Intrinsic", "::", "nvvm_ldu_global_i", ")", "Info", ".", "memVT", "=", "MVT", "::", "i32", ";", "else", "if", "(", "Intrinsic", "==", "Intrinsic", "::", "nvvm_ldu_global_p", ")", "Info", ".", "memVT", "=", "getPointerTy", "(", ")", ";", "else", "Info", ".", "memVT", "=", "MVT", "::", "f32", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "vol", "=", "0", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "Info", ".", "align", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "NVPTX", "NVPTX", "Intrinsic::nvvm_atomic_load_add_f32", "ISD::INTRINSIC_W_CHAIN", "MVT::f32", "0", "0", "0", "0", "Intrinsic::nvvm_atomic_load_inc_32", "Intrinsic::nvvm_atomic_load_dec_32", "ISD::INTRINSIC_W_CHAIN", "MVT::i32", "0", "0", "0", "0", "Intrinsic::nvvm_ldu_global_i", "Intrinsic::nvvm_ldu_global_f", "Intrinsic::nvvm_ldu_global_p", "ISD::INTRINSIC_W_CHAIN", "Intrinsic::nvvm_ldu_global_i", "MVT::i32", "Intrinsic::nvvm_ldu_global_p", "MVT::f32", "0", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "FramePtr", ";", "return", "ARM", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "ARM", "ARM", "ARM::SP" ]

[]

[ "<s>", "BitVector", "IA64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r0", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r1", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r2", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r5", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r12", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r13", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "r22", ")", ";", "Reserved", ".", "set", "(", "IA64", "::", "rp", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64::r0", "IA64::r1", "IA64::r2", "IA64::r5", "IA64::r12", "IA64::r13", "IA64::r22", "IA64::rp" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "Align", ",", "bool", "isSrcConst", ",", "bool", "isSrcStr", ")", "const", "{", "if", "(", "!", "NoImplicitFloat", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "(", "isSrcConst", "||", "isSrcStr", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "Size", ">=", "16", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "(", "isSrcConst", "||", "isSrcStr", ")", "&&", "Subtarget", "->", "hasSSE1", "(", ")", "&&", "Size", ">=", "16", ")", "return", "MVT", "::", "v4f32", ";", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "16", "MVT::v4i32", "16", "MVT::v4f32", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "Is64Bit", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR32", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR32", ")", "{", "++", "I", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"TLS Dynamic Call Fixup:\\n \"", "<<", "*", "MI", ";", ")", ";", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "unsigned", "Opc1", ",", "Opc2", ";", "const", "unsigned", "OrigRegs", "[", "]", "=", "{", "OutReg", ",", "InReg", ",", "GPR3", "}", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode inconsistency error\"", ")", ";", "case", "PPC", "::", "ADDItlsgdLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsgdLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL32", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR32", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL32", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR32", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKDOWN", ")", ")", ".", "addImm", "(", "0", ")", ";", "MachineInstr", "*", "Addi", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc1", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "Addi", "->", "addOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "First", "=", "I", ";", "--", "First", ";", "MachineInstr", "*", "Call", "=", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc2", ")", ",", "GPR3", ")", ".", "addReg", "(", "GPR3", ")", ")", ";", "Call", "->", "addOperand", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKUP", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "MachineBasicBlock", "::", "iterator", "Last", "=", "I", ";", "--", "Last", ";", "++", "I", ";", "MI", "->", "removeFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "&", "MBB", ",", "First", ",", "Last", ",", "OrigRegs", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsldLADDR32", "\"TLS Dynamic Call Fixup:\\n \"", "0", "1", "PPC::X3", "PPC::R3", "\"Opcode inconsistency error\"", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsgdL", "PPC::GETtlsADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsldL", "PPC::GETtlsldADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsgdL32", "PPC::GETtlsADDR32", "PPC::ADDItlsldLADDR32", "PPC::ADDItlsldL32", "PPC::GETtlsldADDR32", "PPC::ADJCALLSTACKDOWN", "0", "2", "3", "PPC::ADJCALLSTACKUP", "0", "0" ]

[]