Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitGlobals", "(", "const", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str2", ";", "raw_svector_ostream", "OS2", "(", "Str2", ")", ";", "emitDeclarations", "(", "M", ",", "OS2", ")", ";", "SmallVector", "<", "const", "GlobalVariable", "*", ",", "8", ">", "Globals", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisited", ";", "DenseSet", "<", "const", "GlobalVariable", "*", ">", "GVVisiting", ";", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "VisitGlobalVariableForEmission", "(", "I", ",", "Globals", ",", "GVVisited", ",", "GVVisiting", ")", ";", "assert", "(", "GVVisited", ".", "size", "(", ")", "==", "M", ".", "getGlobalList", "(", ")", ".", "size", "(", ")", "&&", "\"Missed a global variable\"", ")", ";", "assert", "(", "GVVisiting", ".", "size", "(", ")", "==", "0", "&&", "\"Did not fully process a global variable\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Globals", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "printModuleLevelGV", "(", "Globals", "[", "i", "]", ",", "OS2", ")", ";", "OS2", "<<", "'\\n'", ";", "OutStreamer", ".", "EmitRawText", "(", "OS2", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitGlobals", "-", "Emit", "all", "of", "the", "global", "variables", "to", "memory", ",", "storing", "their", "addresses", "into", "GlobalAddress", "." ]

[ "NVPTX", "NVPTX", "128", "8", "\"Missed a global variable\"", "0", "\"Did not fully process a global variable\"", "0" ]

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilderBase", "&", "IRB", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetAndroid", "(", ")", ")", "return", "UseTlsOffset", "(", "IRB", ",", "0x48", ")", ";", "if", "(", "Subtarget", "->", "isTargetFuchsia", "(", ")", ")", "return", "UseTlsOffset", "(", "IRB", ",", "-", "0x8", ")", ";", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "AArch64", "AArch64", "0x48", "0x8" ]

[]

[ "<s>", "DecodeStatus", "SystemZDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "if", "(", "Bytes", "[", "0", "]", "<", "0x40", ")", "{", "Size", "=", "2", ";", "Table", "=", "DecoderTable16", ";", "}", "else", "if", "(", "Bytes", "[", "0", "]", "<", "0xc0", ")", "{", "Size", "=", "4", ";", "Table", "=", "DecoderTable32", ";", "}", "else", "{", "Size", "=", "6", ";", "Table", "=", "DecoderTable48", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "Size", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint64_t", "Inst", "=", "0", ";", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "8", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "Table", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "2", "0", "0x40", "2", "0", "0xc0", "4", "6", "0", "0", "8" ]

[]

[ "<s>", "const", "MBlazeInstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "SUnit", "*", "R600SchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "SUnit", "*", "SU", "=", "nullptr", ";", "NextInstKind", "=", "IDOther", ";", "IsTopNode", "=", "false", ";", "bool", "AllowSwitchToAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "||", "(", "Available", "[", "CurInstKind", "]", ".", "empty", "(", ")", ")", ";", "bool", "AllowSwitchFromAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "&&", "(", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", "||", "!", "Available", "[", "IDOther", "]", ".", "empty", "(", ")", ")", ";", "if", "(", "CurInstKind", "==", "IDAlu", "&&", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", ")", "{", "float", "ALUFetchRationEstimate", "=", "(", "AluInstCount", "+", "AvailablesAluCount", "(", ")", "+", "Pending", "[", "IDAlu", "]", ".", "size", "(", ")", ")", "/", "(", "FetchInstCount", "+", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ")", ";", "if", "(", "ALUFetchRationEstimate", "==", "0", ")", "{", "AllowSwitchFromAlu", "=", "true", ";", "}", "else", "{", "unsigned", "NeededWF", "=", "62.5f", "/", "ALUFetchRationEstimate", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "NeededWF", "<<", "\" approx. Wavefronts Required\\n\"", ")", ";", "unsigned", "NearRegisterRequirement", "=", "2", "*", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ";", "if", "(", "NeededWF", ">", "getWFCountLimitedByGPR", "(", "NearRegisterRequirement", ")", ")", "AllowSwitchFromAlu", "=", "true", ";", "}", "}", "if", "(", "!", "SU", "&&", "(", "(", "AllowSwitchToAlu", "&&", "CurInstKind", "!=", "IDAlu", ")", "||", "(", "!", "AllowSwitchFromAlu", "&&", "CurInstKind", "==", "IDAlu", ")", ")", ")", "{", "SU", "=", "pickAlu", "(", ")", ";", "if", "(", "!", "SU", "&&", "!", "PhysicalRegCopy", ".", "empty", "(", ")", ")", "{", "SU", "=", "PhysicalRegCopy", ".", "front", "(", ")", ";", "PhysicalRegCopy", ".", "erase", "(", "PhysicalRegCopy", ".", "begin", "(", ")", ")", ";", "}", "if", "(", "SU", ")", "{", "if", "(", "CurEmitted", ">=", "InstKindLimit", "[", "IDAlu", "]", ")", "CurEmitted", "=", "0", ";", "NextInstKind", "=", "IDAlu", ";", "}", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDFetch", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDFetch", ";", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDOther", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDOther", ";", "}", "LLVM_DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\" ** Pick node **\\n\"", ";", "DAG", "->", "dumpNode", "(", "*", "SU", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "DAG", "->", "dumpNode", "(", "S", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "0", "62.5f", "\" approx. Wavefronts Required\\n\"", "2", "0", "\" ** Pick node **\\n\"", "\"NO NODE \\n\"", "0" ]

[]

[ "<s>", "bool", "LinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "DW", "->", "EndModule", "(", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "CellSPU" ]

[]

[ "<s>", "void", "s390_function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "{", "cum", "->", "fprs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "cum", "->", "gprs", "+=", "(", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available.", ")", ".", "The", "boolean", "NAMED", "specifies", "whether", "the", "argument", "is", "a", "named", "argument", "(", "as", "opposed", "to", "an", "unnamed", "argument", "matching", "an", "ellipsis", ")", "." ]

[ "s390", "1", "1" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_preferred_doloop_mode", "(", "machine_mode", ")", "{", "return", "word_mode", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_DOLOOP_MODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "enum", "reg_class", "s390_preferred_reload_class", "(", "rtx", "op", ",", "enum", "reg_class", "class", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_DOUBLE", ":", "case", "CONST_INT", ":", "if", "(", "legitimate_reload_constant_p", "(", "op", ")", ")", "return", "class", ";", "else", "return", "NO_REGS", ";", "case", "PLUS", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "if", "(", "reg_class_subset_p", "(", "ADDR_REGS", ",", "class", ")", ")", "return", "ADDR_REGS", ";", "else", "return", "NO_REGS", ";", "default", ":", "break", ";", "}", "return", "class", ";", "}", "</s>" ]

[ "Given", "an", "rtx", "OP", "being", "reloaded", "into", "a", "reg", "required", "to", "be", "in", "class", "CLASS", ",", "return", "the", "class", "of", "reg", "to", "actually", "use", "." ]

[ "s390" ]

[]

[ "<s>", "int64_t", "getOffset", "(", ")", "{", "return", "Offset", ";", "}", "</s>" ]

[ "Get", "the", "offest", "of", "a", "string", "in", "the", "string", "table", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "rs6000_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "rs6000_warn_cell_microcode", ")", "{", "const", "char", "*", "temp", ";", "int", "insn_code_number", "=", "recog_memoized", "(", "insn", ")", ";", "location_t", "location", "=", "INSN_LOCATION", "(", "insn", ")", ";", "if", "(", "insn_code_number", "<", "0", ")", "return", ";", "temp", "=", "get_insn_template", "(", "insn_code_number", ",", "insn", ")", ";", "if", "(", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_ALWAYS", ")", "warning_at", "(", "location", ",", "OPT_mwarn_cell_microcode", ",", "\"emitting microcode insn %s\\t[%s] #%d\"", ",", "temp", ",", "insn_data", "[", "INSN_CODE", "(", "insn", ")", "]", ".", "name", ",", "INSN_UID", "(", "insn", ")", ")", ";", "else", "if", "(", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_CONDITIONAL", ")", "warning_at", "(", "location", ",", "OPT_mwarn_cell_microcode", ",", "\"emitting conditional microcode insn %s\\t[%s] #%d\"", ",", "temp", ",", "insn_data", "[", "INSN_CODE", "(", "insn", ")", "]", ".", "name", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]

[ "Define", "FINAL_PRESCAN_INSN", "if", "some", "processing", "needs", "to", "be", "done", "before", "outputting", "the", "assembler", "code", ".", "On", "the", "PowerPC", ",", "we", "remember", "if", "the", "current", "insn", "is", "a", "prefixed", "insn", "where", "we", "need", "to", "emit", "a", "'", "p", "'", "before", "the", "insn", ".", "In", "addition", ",", "if", "the", "insn", "is", "part", "of", "a", "PC-relative", "reference", "to", "an", "external", "label", "optimization", ",", "this", "is", "recorded", "also", "." ]

[ "rs6000", "0", "\"emitting microcode insn %s\\t[%s] #%d\"", "\"emitting conditional microcode insn %s\\t[%s] #%d\"" ]

[]

[ "<s>", "virtual", "const", "MCSection", "*", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "Z80" ]

[]

[ "<s>", "bool", "pass_vsetvl", "::", "hard_empty_block_p", "(", "const", "bb_info", "*", "bb", ",", "const", "vector_insn_info", "&", "info", ")", "const", "{", "if", "(", "!", "info", ".", "dirty_p", "(", ")", "||", "!", "info", ".", "has_avl_reg", "(", ")", ")", "return", "false", ";", "basic_block", "cfg_bb", "=", "bb", "->", "cfg_bb", "(", ")", ";", "sbitmap", "avin", "=", "m_vector_manager", "->", "vector_avin", "[", "cfg_bb", "->", "index", "]", ";", "set_info", "*", "set", "=", "info", ".", "get_avl_source", "(", ")", ";", "rtx", "avl", "=", "gen_rtx_REG", "(", "Pmode", ",", "set", "->", "regno", "(", ")", ")", ";", "hash_set", "<", "set_info", "*", ">", "sets", "=", "get_all_sets", "(", "set", ",", "true", ",", "false", ",", "false", ")", ";", "hash_set", "<", "basic_block", ">", "pred_cfg_bbs", "=", "get_all_predecessors", "(", "cfg_bb", ")", ";", "if", "(", "find_reg_killed_by", "(", "bb", ",", "avl", ")", ")", "{", "gcc_assert", "(", "info", ".", "dirty_with_killed_avl_p", "(", ")", ")", ";", "if", "(", "info", ".", "get_avl_source", "(", ")", "&&", "get_same_bb_set", "(", "sets", ",", "bb", "->", "cfg_bb", "(", ")", ")", "==", "info", ".", "get_avl_source", "(", ")", ")", "return", "false", ";", "}", "if", "(", "bitmap_empty_p", "(", "avin", ")", ")", "{", "bool", "hard_empty_p", "=", "true", ";", "for", "(", "const", "basic_block", "pred_cfg_bb", ":", "pred_cfg_bbs", ")", "{", "if", "(", "pred_cfg_bb", "==", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "continue", ";", "sbitmap", "avout", "=", "m_vector_manager", "->", "vector_avout", "[", "pred_cfg_bb", "->", "index", "]", ";", "if", "(", "!", "bitmap_empty_p", "(", "avout", ")", ")", "{", "hard_empty_p", "=", "false", ";", "break", ";", "}", "}", "if", "(", "hard_empty_p", ")", "return", "true", ";", "}", "edge", "e", ";", "edge_iterator", "ei", ";", "bool", "has_avl_killed_insn_p", "=", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "cfg_bb", "->", "succs", ")", "{", "const", "auto", "block_info", "=", "m_vector_manager", "->", "vector_block_infos", "[", "e", "->", "dest", "->", "index", "]", ";", "if", "(", "block_info", ".", "local_dem", ".", "dirty_with_killed_avl_p", "(", ")", ")", "{", "has_avl_killed_insn_p", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "has_avl_killed_insn_p", ")", "return", "false", ";", "bool", "any_set_in_bbs_p", "=", "false", ";", "for", "(", "const", "basic_block", "pred_cfg_bb", ":", "pred_cfg_bbs", ")", "{", "insn_info", "*", "def_insn", "=", "extract_single_source", "(", "set", ")", ";", "if", "(", "def_insn", ")", "{", "insn_info", "*", "last_killed_insn", "=", "find_reg_killed_by", "(", "crtl", "->", "ssa", "->", "bb", "(", "pred_cfg_bb", ")", ",", "avl", ")", ";", "if", "(", "!", "last_killed_insn", "||", "pred_cfg_bb", "==", "def_insn", "->", "bb", "(", ")", "->", "cfg_bb", "(", ")", ")", "continue", ";", "if", "(", "source_equal_p", "(", "last_killed_insn", ",", "def_insn", ")", ")", "{", "any_set_in_bbs_p", "=", "true", ";", "break", ";", "}", "}", "else", "{", "if", "(", "any_set_in_bb_p", "(", "sets", ",", "crtl", "->", "ssa", "->", "bb", "(", "pred_cfg_bb", ")", ")", ")", "{", "any_set_in_bbs_p", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "!", "any_set_in_bbs_p", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "We", "almost", "enable", "all", "cases", "in", "get_backward_fusion_type", ",", "this", "function", "disable", "the", "backward", "fusion", "by", "changing", "dirty", "blocks", "into", "hard", "empty", "blocks", "in", "forward", "dataflow", ".", "We", "can", "have", "more", "accurate", "optimization", "by", "this", "method", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "CookieSetter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "CookieCheck", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Setting cookies for \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LowerSetCookieInstrs", "(", "MF", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"Setting cookies for \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "GCNHazardRecognizer", "::", "ShouldPreferAnother", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "->", "isInstr", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "MAI", "=", "nullptr", ";", "auto", "IsMFMAFn", "=", "[", "&", "MAI", "]", "(", "MachineInstr", "*", "MI", ")", "{", "MAI", "=", "nullptr", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32_e64", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_READ_B32_e64", ")", "MAI", "=", "MI", ";", "return", "MAI", "!=", "nullptr", ";", "}", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "IsMFMAFn", "(", "MI", ")", ")", "{", "int", "W", "=", "getWaitStatesSince", "(", "IsMFMAFn", ",", "16", ")", ";", "if", "(", "MAI", ")", "return", "W", "<", "(", "int", ")", "TSchedModel", ".", "computeInstrLatency", "(", "MAI", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ShouldPreferAnother", "-", "This", "callback", "may", "be", "invoked", "if", "getHazardType", "returns", "NoHazard", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ACCVGPR_WRITE_B32_e64", "AMDGPU::V_ACCVGPR_READ_B32_e64", "16" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA9", "(", ")", ")", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA15", "(", ")", "&&", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", "&&", "!", "DisableA15SDOptimization", ")", "{", "addPass", "(", "createA15SDOptimizerPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "bpf_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", "ATTRIBUTE_UNUSED", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s\\n\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "directives", "to", "switch", "to", "section", "NAME", ".", "The", "section", "should", "have", "attributes", "as", "specified", "by", "FLAGS", ",", "which", "is", "a", "bit", "mask", "of", "the", "'SECTION_", "*", "'", "flags", "defined", "in", "'output.h", "'", ".", "If", "DECL", "is", "non-NULL", ",", "it", "is", "the", "'VAR_DECL", "'", "or", "'FUNCTION_DECL", "'", "with", "which", "this", "section", "is", "associated", "." ]

[ "bpf", "\"\\t.section\\t%s\\n\"" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFixControlFlowLiveIntervalsID", ")", ";", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "rs6000_indirect_call_template_1", "(", "rtx", "*", "operands", ",", "unsigned", "int", "funop", ",", "bool", "sibcall", ")", "{", "gcc_assert", "(", "funop", "<=", "MAX_RECOG_OPERANDS", ")", ";", "static", "char", "str", "[", "160", "]", ";", "char", "*", "s", "=", "str", ";", "const", "char", "*", "ptrload", "=", "TARGET_64BIT", "?", "\"d\"", ":", "\"wz\"", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", ")", "s", "+=", "sprintf", "(", "s", ",", "\"l%s 2,%%%u\\n\\t\"", ",", "ptrload", ",", "funop", "+", "3", ")", ";", "bool", "speculate", "=", "(", "TARGET_MACHO", "||", "rs6000_speculate_indirect_jumps", "||", "(", "REG_P", "(", "operands", "[", "funop", "]", ")", "&&", "REGNO", "(", "operands", "[", "funop", "]", ")", "==", "LR_REGNO", ")", ")", ";", "if", "(", "TARGET_PLTSEQ", "&&", "GET_CODE", "(", "operands", "[", "funop", "]", ")", "==", "UNSPEC", ")", "{", "const", "char", "*", "rel64", "=", "TARGET_64BIT", "?", "\"64\"", ":", "\"\"", ";", "char", "tls", "[", "29", "]", ";", "tls", "[", "0", "]", "=", "0", ";", "if", "(", "GET_CODE", "(", "operands", "[", "funop", "+", "1", "]", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "sprintf", "(", "tls", ",", "\".reloc .,R_PPC%s_TLSGD,%%%u\\n\\t\"", ",", "rel64", ",", "funop", "+", "1", ")", ";", "else", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "sprintf", "(", "tls", ",", "\".reloc .,R_PPC%s_TLSLD,%%&\\n\\t\"", ",", "rel64", ")", ";", "}", "const", "char", "*", "notoc", "=", "rs6000_pcrel_p", "(", ")", "?", "\"_NOTOC\"", ":", "\"\"", ";", "const", "char", "*", "addend", "=", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_SECURE_PLT", "&&", "flag_pic", "==", "2", "?", "\"+32768\"", ":", "\"\"", ")", ";", "if", "(", "!", "speculate", ")", "{", "s", "+=", "sprintf", "(", "s", ",", "\"%s.reloc .,R_PPC%s_PLTSEQ%s,%%z%u%s\\n\\t\"", ",", "tls", ",", "rel64", ",", "notoc", ",", "funop", ",", "addend", ")", ";", "s", "+=", "sprintf", "(", "s", ",", "\"crset 2\\n\\t\"", ")", ";", "}", "s", "+=", "sprintf", "(", "s", ",", "\"%s.reloc .,R_PPC%s_PLTCALL%s,%%z%u%s\\n\\t\"", ",", "tls", ",", "rel64", ",", "notoc", ",", "funop", ",", "addend", ")", ";", "}", "else", "if", "(", "!", "speculate", ")", "s", "+=", "sprintf", "(", "s", ",", "\"crset 2\\n\\t\"", ")", ";", "if", "(", "rs6000_pcrel_p", "(", ")", ")", "{", "if", "(", "speculate", ")", "sprintf", "(", "s", ",", "\"b%%T%ul\"", ",", "funop", ")", ";", "else", "sprintf", "(", "s", ",", "\"beq%%T%ul-\"", ",", "funop", ")", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "if", "(", "speculate", ")", "sprintf", "(", "s", ",", "\"b%%T%ul\\n\\t\"", "\"l%s 2,%%%u(1)\"", ",", "funop", ",", "ptrload", ",", "funop", "+", "4", ")", ";", "else", "sprintf", "(", "s", ",", "\"beq%%T%ul-\\n\\t\"", "\"l%s 2,%%%u(1)\"", ",", "funop", ",", "ptrload", ",", "funop", "+", "4", ")", ";", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "if", "(", "speculate", ")", "sprintf", "(", "s", ",", "\"b%%T%ul\\n\\t\"", "\"l%s 2,%%%u(1)\"", ",", "funop", ",", "ptrload", ",", "funop", "+", "3", ")", ";", "else", "sprintf", "(", "s", ",", "\"beq%%T%ul-\\n\\t\"", "\"l%s 2,%%%u(1)\"", ",", "funop", ",", "ptrload", ",", "funop", "+", "3", ")", ";", "}", "else", "{", "if", "(", "speculate", ")", "sprintf", "(", "s", ",", "\"b%%T%u%s\"", ",", "funop", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ")", ";", "else", "sprintf", "(", "s", ",", "\"beq%%T%u%s-%s\"", ",", "funop", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "sibcall", "?", "\"\\n\\tb $\"", ":", "\"\"", ")", ";", "}", "return", "str", ";", "}", "</s>" ]

[ "As", "above", ",", "for", "indirect", "calls", "." ]

[ "rs6000", "160", "\"d\"", "\"wz\"", "\"l%s 2,%%%u\\n\\t\"", "3", "\"64\"", "\"\"", "29", "0", "0", "1", "1", "1", "\".reloc .,R_PPC%s_TLSGD,%%%u\\n\\t\"", "1", "1", "1", "\".reloc .,R_PPC%s_TLSLD,%%&\\n\\t\"", "\"_NOTOC\"", "\"\"", "2", "\"+32768\"", "\"\"", "\"%s.reloc .,R_PPC%s_PLTSEQ%s,%%z%u%s\\n\\t\"", "\"crset 2\\n\\t\"", "\"%s.reloc .,R_PPC%s_PLTCALL%s,%%z%u%s\\n\\t\"", "\"crset 2\\n\\t\"", "\"b%%T%ul\"", "\"beq%%T%ul-\"", "\"b%%T%ul\\n\\t\"", "\"l%s 2,%%%u(1)\"", "4", "\"beq%%T%ul-\\n\\t\"", "\"l%s 2,%%%u(1)\"", "4", "\"b%%T%ul\\n\\t\"", "\"l%s 2,%%%u(1)\"", "3", "\"beq%%T%ul-\\n\\t\"", "\"l%s 2,%%%u(1)\"", "3", "\"b%%T%u%s\"", "\"\"", "\"l\"", "\"beq%%T%u%s-%s\"", "\"\"", "\"l\"", "\"\\n\\tb $\"", "\"\"" ]

[]

[ "<s>", "void", "loongarch_expand_conditional_move", "(", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op1", ")", ")", ")", "loongarch_emit_float_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "else", "{", "loongarch_extend_comparands", "(", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "op0", "=", "force_reg", "(", "word_mode", ",", "op0", ")", ";", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "op0", "=", "loongarch_zero_if_equal", "(", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "}", "else", "{", "bool", "invert", "=", "false", ";", "rtx", "target", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "op0", ")", ")", ";", "loongarch_emit_int_order_test", "(", "code", ",", "&", "invert", ",", "target", ",", "op0", ",", "op1", ")", ";", "code", "=", "invert", "?", "EQ", ":", "NE", ";", "op0", "=", "target", ";", "op1", "=", "const0_rtx", ";", "}", "}", "rtx", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ";", "if", "(", "INTEGRAL_MODE_P", "(", "GET_MODE", "(", "operands", "[", "2", "]", ")", ")", "&&", "register_operand", "(", "operands", "[", "2", "]", ",", "VOIDmode", ")", "&&", "register_operand", "(", "operands", "[", "3", "]", ",", "VOIDmode", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "temp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "temp2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "operands", "[", "2", "]", ",", "const0_rtx", ")", ")", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "(", "code", "==", "EQ", ")", "?", "NE", ":", "EQ", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp2", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "operands", "[", "3", "]", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "mode", ",", "temp", ",", "temp2", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "cond", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "Perform", "the", "comparison", "in", "OPERANDS", "[", "1", "]", ".", "Move", "OPERANDS", "[", "2", "]", "into", "OPERANDS", "[", "0", "]", "if", "the", "condition", "holds", ",", "otherwise", "move", "OPERANDS", "[", "3", "]", "into", "OPERANDS", "[", "0", "]", "." ]

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

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "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", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_BUILTIN", ")", "{", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_AVR_BUILTIN", ")", ";", "}", "else", "{", "analyzeReturnValues", "(", "Outs", ",", "CCInfo", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "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", ";", "}", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpc", "=", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "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", "." ]

[ "AVR", "AVR", "ISD::OutputArg", "16", "AVR", "AVR", "4", "1", "0", "\"Can only return in registers!\"", "1", "AVR", "AVR", "AVRISD::RETI_FLAG", "AVRISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "can_use_callp", "(", "rtx_insn", "*", "insn", ")", "{", "int", "icode", "=", "recog_memoized", "(", "insn", ")", ";", "if", "(", "!", "TARGET_INSNS_64PLUS", "||", "icode", "<", "0", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", ")", "return", "false", ";", "return", "(", "(", "icode", "==", "CODE_FOR_real_call", "||", "icode", "==", "CODE_FOR_call_internal", "||", "icode", "==", "CODE_FOR_call_value_internal", ")", "&&", "get_attr_dest_regfile", "(", "insn", ")", "==", "DEST_REGFILE_ANY", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "INSN", "'s", "pattern", "can", "be", "converted", "to", "use", "callp", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "EmitFPOData", "=", "Subtarget", "->", "isTargetWin32", "(", ")", "&&", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getCodeViewFlag", "(", ")", ";", "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", "(", ")", ";", "EmitFPOData", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOps", ",", "bool", "OptForSize", ",", "NegatibleCost", "&", "Cost", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "Depth", ">", "SelectionDAG", "::", "MaxRecursionDepth", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", "=", "Op", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "PPCISD", "::", "FNMSUB", ":", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", "||", "!", "isTypeLegal", "(", "VT", ")", ")", "break", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "SDValue", "N2", "=", "Op", ".", "getOperand", "(", "2", ")", ";", "SDLoc", "Loc", "(", "Op", ")", ";", "NegatibleCost", "N2Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN2", "=", "getNegatedExpression", "(", "N2", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N2Cost", ",", "Depth", "+", "1", ")", ";", "if", "(", "!", "NegN2", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Flags", ".", "hasNoSignedZeros", "(", ")", "||", "Options", ".", "NoSignedZerosFPMath", ")", "{", "NegatibleCost", "N0Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN0", "=", "getNegatedExpression", "(", "N0", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N0Cost", ",", "Depth", "+", "1", ")", ";", "NegatibleCost", "N1Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN1", "=", "getNegatedExpression", "(", "N1", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N1Cost", ",", "Depth", "+", "1", ")", ";", "if", "(", "NegN0", "&&", "N0Cost", "<=", "N1Cost", ")", "{", "Cost", "=", "std", "::", "min", "(", "N0Cost", ",", "N2Cost", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "Loc", ",", "VT", ",", "NegN0", ",", "N1", ",", "NegN2", ",", "Flags", ")", ";", "}", "else", "if", "(", "NegN1", ")", "{", "Cost", "=", "std", "::", "min", "(", "N1Cost", ",", "N2Cost", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "Loc", ",", "VT", ",", "N0", ",", "NegN1", ",", "NegN2", ",", "Flags", ")", ";", "}", "}", "if", "(", "isOperationLegal", "(", "ISD", "::", "FMA", ",", "VT", ")", ")", "{", "Cost", "=", "N2Cost", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FMA", ",", "Loc", ",", "VT", ",", "N0", ",", "N1", ",", "NegN2", ",", "Flags", ")", ";", "}", "break", ";", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "Cost", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "the", "newly", "negated", "expression", "if", "the", "cost", "is", "not", "expensive", "and", "set", "the", "cost", "in", "Cost", "to", "indicate", "that", "if", "it", "is", "cheaper", "or", "neutral", "to", "do", "the", "negation", "." ]

[ "PowerPC", "PPC", "PPCISD::FNMSUB", "0", "1", "2", "1", "1", "1", "ISD::FMA", "ISD::FMA" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "return", "false", ";", "}", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "EntryMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "EntryMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "SPCopy", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "GB", "::", "DREGSRegClass", ")", ";", "BuildMI", "(", "EntryMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "COPY", ")", ",", "SPCopy", ")", ".", "addReg", "(", "GB", "::", "SP", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", "&&", "MBB", ".", "back", "(", ")", ".", "isReturn", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "COPY", ")", ",", "GB", "::", "SP", ")", ".", "addReg", "(", "SPCopy", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB::DREGSRegClass", "GB::COPY", "GB::SP", "GB::COPY", "GB::SP" ]

[]

[ "<s>", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "&", "getBlocksVector", "(", ")", "{", "return", "Blocks", ";", "}", "</s>" ]

[ "Return", "a", "direct", ",", "mutable", "handle", "to", "the", "blocks", "vector", "so", "that", "we", "can", "mutate", "it", "efficiently", "with", "techniques", "like", "std", ":", ":remove", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", "==", "FPReg", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "Type", "*", "RetTy", "=", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ";", "bool", "isABI", "=", "(", "STI", ".", "getSmVersion", "(", ")", ">=", "20", ")", ";", "assert", "(", "isABI", "&&", "\"Non-ABI compilation is not supported\"", ")", ";", "if", "(", "!", "isABI", ")", "return", "Chain", ";", "const", "DataLayout", "DL", "=", "DAG", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "EVT", ",", "16", ">", "VTs", ";", "SmallVector", "<", "uint64_t", ",", "16", ">", "Offsets", ";", "ComputePTXValueVTs", "(", "*", "this", ",", "DL", ",", "RetTy", ",", "VTs", ",", "&", "Offsets", ")", ";", "assert", "(", "VTs", ".", "size", "(", ")", "==", "OutVals", ".", "size", "(", ")", "&&", "\"Bad return value decomposition\"", ")", ";", "auto", "VectorInfo", "=", "VectorizePTXValueVTs", "(", "VTs", ",", "Offsets", ",", "RetTy", "->", "isSized", "(", ")", "?", "DL", ".", "getABITypeAlignment", "(", "RetTy", ")", ":", "1", ")", ";", "bool", "ExtendIntegerRetVal", "=", "RetTy", "->", "isIntegerTy", "(", ")", "&&", "DL", ".", "getTypeAllocSizeInBits", "(", "RetTy", ")", "<", "32", ";", "SmallVector", "<", "SDValue", ",", "6", ">", "StoreOperands", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "VTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "VectorInfo", "[", "i", "]", "&", "PVF_FIRST", ")", "{", "assert", "(", "StoreOperands", ".", "empty", "(", ")", "&&", "\"Orphaned operand list.\"", ")", ";", "StoreOperands", ".", "push_back", "(", "Chain", ")", ";", "StoreOperands", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "Offsets", "[", "i", "]", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "SDValue", "RetVal", "=", "OutVals", "[", "i", "]", ";", "if", "(", "ExtendIntegerRetVal", ")", "{", "RetVal", "=", "DAG", ".", "getNode", "(", "Outs", "[", "i", "]", ".", "Flags", ".", "isSExt", "(", ")", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "RetVal", ")", ";", "}", "else", "if", "(", "RetVal", ".", "getValueSizeInBits", "(", ")", "<", "16", ")", "{", "RetVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i16", ",", "RetVal", ")", ";", "}", "StoreOperands", ".", "push_back", "(", "RetVal", ")", ";", "if", "(", "VectorInfo", "[", "i", "]", "&", "PVF_LAST", ")", "{", "NVPTXISD", "::", "NodeType", "Op", ";", "unsigned", "NumElts", "=", "StoreOperands", ".", "size", "(", ")", "-", "2", ";", "switch", "(", "NumElts", ")", "{", "case", "1", ":", "Op", "=", "NVPTXISD", "::", "StoreRetval", ";", "break", ";", "case", "2", ":", "Op", "=", "NVPTXISD", "::", "StoreRetvalV2", ";", "break", ";", "case", "4", ":", "Op", "=", "NVPTXISD", "::", "StoreRetvalV4", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid vector info.\"", ")", ";", "}", "EVT", "TheStoreType", "=", "ExtendIntegerRetVal", "?", "MVT", "::", "i32", ":", "VTs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getMemIntrinsicNode", "(", "Op", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ",", "StoreOperands", ",", "TheStoreType", ",", "MachinePointerInfo", "(", ")", ",", "1", ")", ";", "StoreOperands", ".", "clear", "(", ")", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "NVPTXISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::OutputArg", "20", "\"Non-ABI compilation is not supported\"", "16", "16", "\"Bad return value decomposition\"", "1", "32", "6", "0", "\"Orphaned operand list.\"", "MVT::i32", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "MVT::i32", "16", "ISD::ANY_EXTEND", "MVT::i16", "NVPTXISD::NodeType", "2", "1", "NVPTXISD::StoreRetval", "2", "NVPTXISD::StoreRetvalV2", "4", "NVPTXISD::StoreRetvalV4", "\"Invalid vector info.\"", "MVT::i32", "MVT::Other", "1", "NVPTXISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "<=", "UINT32_MAX", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "static_cast", "<", "uint32_t", ">", "(", "Value", ")", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "Value", "=", "(", "uint32_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "Endian", "==", "support", "::", "little", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x10", ";", "support", "::", "endian", "::", "write32le", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x1", ";", "support", "::", "endian", "::", "write32be", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "int64_t", "ByteOff", "=", "(", "int64_t", ")", "Value", "-", "8", ";", "if", "(", "ByteOff", ">", "INT16_MAX", "*", "8", "||", "ByteOff", "<", "INT16_MIN", "*", "8", ")", "report_fatal_error", "(", "\"Branch target out of insn range\"", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", ",", "Value", ",", "Endian", ")", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "support::endian", "4", "support::endian", "support::endian", "8", "8", "support::little", "1", "0x10", "support::endian", "4", "1", "0x1", "support::endian", "4", "8", "8", "8", "\"Branch target out of insn range\"", "8", "8", "support::endian", "2" ]

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "Mandarin", "MVT::i32" ]

[]

[ "<s>", "static", "void", "ix86_warn_parameter_passing_abi", "(", "cumulative_args_t", "cum_v", ",", "tree", "type", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "cum", "->", "warn_empty", ")", "return", ";", "if", "(", "!", "TYPE_EMPTY_P", "(", "type", ")", ")", "return", ";", "const_tree", "ctx", "=", "get_ultimate_context", "(", "cum", "->", "decl", ")", ";", "if", "(", "ctx", "!=", "NULL_TREE", "&&", "!", "TRANSLATION_UNIT_WARN_EMPTY_P", "(", "ctx", ")", ")", "return", ";", "if", "(", "int_size_in_bytes", "(", "type", ")", "==", "0", ")", "return", ";", "warning", "(", "OPT_Wabi", ",", "\"empty class %qT parameter passing ABI \"", "\"changes in -fabi-version=12 (GCC 8)\"", ",", "type", ")", ";", "cum", "->", "warn_empty", "=", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_WARN_PARAMETER_PASSING_ABI", "." ]

[ "i386", "0", "\"empty class %qT parameter passing ABI \"", "\"changes in -fabi-version=12 (GCC 8)\"" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<=", "INT_MAX", "&&", "\"Offset too big to fit in int.\"", ")", ";", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "int", "SaveOffset", "=", "Offset", ";", "return", "isAArch64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "AArch64FrameOffsetIsLegal", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Offset too big to fit in int.\"", "\"Unable to get the legal offset for nil instruction.\"", "AArch64", "AArch64" ]

[]

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

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

[ "PowerPC", "PPC", "PPC", "PPC", "\"the default AIX Altivec ABI is not yet \"", "\"supported.\"", "PPC", "\"AnyReg unimplemented on 32-bit AIX.\"", "PPC::X2", "\"Cold calling unimplemented on AIX.\"", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "ARM64BranchRelaxation", "::", "verify", "(", ")", "{", "unsigned", "PrevNum", "=", "MF", "->", "begin", "(", ")", "->", "getNumber", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "unsigned", "Align", "=", "MBB", ".", "getAlignment", "(", ")", ";", "unsigned", "Num", "=", "MBB", ".", "getNumber", "(", ")", ";", "assert", "(", "BlockInfo", "[", "Num", "]", ".", "Offset", "%", "(", "1u", "<<", "Align", ")", "==", "0", ")", ";", "assert", "(", "!", "Num", "||", "BlockInfo", "[", "PrevNum", "]", ".", "postOffset", "(", ")", "<=", "BlockInfo", "[", "Num", "]", ".", "Offset", ")", ";", "PrevNum", "=", "Num", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM64", "ARM64", "1u", "0" ]

[]

[ "<s>", "void", "altivec_expand_stvx_be", "(", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "mode", ",", "unsigned", "unspec", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "store", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "tmp", ")", ";", "rtx", "stvx", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "unspec", ")", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "store", ",", "stvx", ")", ")", ";", "rtx", "sel", "=", "swap_selector_for_mode", "(", "mode", ")", ";", "rtx", "vperm", ";", "gcc_assert", "(", "REG_P", "(", "op1", ")", ")", ";", "vperm", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op1", ",", "sel", ")", ",", "UNSPEC_VPERM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "vperm", ")", ")", ";", "emit_insn", "(", "par", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "a", "``", "stvx", "''", "or", "``", "stvxl", "''", "built-in", "for", "a", "little", "endian", "target", "with", "-maltivec=be", "specified", ".", "Issue", "the", "store", "preceded", "by", "an", "element-reversing", "permute", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon remove redundant zero and size extends\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon remove redundant zero and size extends\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isAssociativeAndCommutative", "(", "const", "MachineInstr", "&", "Inst", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "PPC", "::", "FADD", ":", "case", "PPC", "::", "FADDS", ":", "case", "PPC", "::", "FMUL", ":", "case", "PPC", "::", "FMULS", ":", "case", "PPC", "::", "VADDFP", ":", "case", "PPC", "::", "XSADDDP", ":", "case", "PPC", "::", "XVADDDP", ":", "case", "PPC", "::", "XVADDSP", ":", "case", "PPC", "::", "XSADDSP", ":", "case", "PPC", "::", "XSMULDP", ":", "case", "PPC", "::", "XVMULDP", ":", "case", "PPC", "::", "XVMULSP", ":", "case", "PPC", "::", "XSMULSP", ":", "case", "PPC", "::", "QVFADD", ":", "case", "PPC", "::", "QVFADDS", ":", "case", "PPC", "::", "QVFADDSs", ":", "case", "PPC", "::", "QVFMUL", ":", "case", "PPC", "::", "QVFMULS", ":", "case", "PPC", "::", "QVFMULSs", ":", "return", "Inst", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmReassoc", ")", "&&", "Inst", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmNsz", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "is", "both", "associative", "and", "commutative", "." ]

[ "PowerPC", "PPC", "PPC::FADD", "PPC::FADDS", "PPC::FMUL", "PPC::FMULS", "PPC::VADDFP", "PPC::XSADDDP", "PPC::XVADDDP", "PPC::XVADDSP", "PPC::XSADDSP", "PPC::XSMULDP", "PPC::XVMULDP", "PPC::XVMULSP", "PPC::XSMULSP", "PPC::QVFADD", "PPC::QVFADDS", "PPC::QVFADDSs", "PPC::QVFMUL", "PPC::QVFMULS", "PPC::QVFMULSs" ]

[]

[ "<s>", "const", "uint16_t", "*", "TLCS900RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "TLCS900", "::", "FPW", ",", "TLCS900", "::", "R5W", ",", "TLCS900", "::", "R6W", ",", "TLCS900", "::", "R7W", ",", "TLCS900", "::", "R8W", ",", "TLCS900", "::", "R9W", ",", "TLCS900", "::", "R10W", ",", "TLCS900", "::", "R11W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "TLCS900", "::", "R5W", ",", "TLCS900", "::", "R6W", ",", "TLCS900", "::", "R7W", ",", "TLCS900", "::", "R8W", ",", "TLCS900", "::", "R9W", ",", "TLCS900", "::", "R10W", ",", "TLCS900", "::", "R11W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntr", "[", "]", "=", "{", "TLCS900", "::", "FPW", ",", "TLCS900", "::", "R5W", ",", "TLCS900", "::", "R6W", ",", "TLCS900", "::", "R7W", ",", "TLCS900", "::", "R8W", ",", "TLCS900", "::", "R9W", ",", "TLCS900", "::", "R10W", ",", "TLCS900", "::", "R11W", ",", "TLCS900", "::", "R12W", ",", "TLCS900", "::", "R13W", ",", "TLCS900", "::", "R14W", ",", "TLCS900", "::", "R15W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "TLCS900", "::", "R5W", ",", "TLCS900", "::", "R6W", ",", "TLCS900", "::", "R7W", ",", "TLCS900", "::", "R8W", ",", "TLCS900", "::", "R9W", ",", "TLCS900", "::", "R10W", ",", "TLCS900", "::", "R11W", ",", "TLCS900", "::", "R12W", ",", "TLCS900", "::", "R13W", ",", "TLCS900", "::", "R14W", ",", "TLCS900", "::", "R15W", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "TLCS900_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "TLCS900_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "TLCS900", "TLCS900", "TLCS900::FPW", "TLCS900::R5W", "TLCS900::R6W", "TLCS900::R7W", "TLCS900::R8W", "TLCS900::R9W", "TLCS900::R10W", "TLCS900::R11W", "0", "TLCS900::R5W", "TLCS900::R6W", "TLCS900::R7W", "TLCS900::R8W", "TLCS900::R9W", "TLCS900::R10W", "TLCS900::R11W", "0", "TLCS900::FPW", "TLCS900::R5W", "TLCS900::R6W", "TLCS900::R7W", "TLCS900::R8W", "TLCS900::R9W", "TLCS900::R10W", "TLCS900::R11W", "TLCS900::R12W", "TLCS900::R13W", "TLCS900::R14W", "TLCS900::R15W", "0", "TLCS900::R5W", "TLCS900::R6W", "TLCS900::R7W", "TLCS900::R8W", "TLCS900::R9W", "TLCS900::R10W", "TLCS900::R11W", "TLCS900::R12W", "TLCS900::R13W", "TLCS900::R14W", "TLCS900::R15W", "0", "TLCS900", "TLCS900" ]

[]

[ "<s>", "static", "unsigned", "selectBinaryOp", "(", "unsigned", "GenericOpc", ",", "unsigned", "RegBankID", ",", "unsigned", "OpSize", ")", "{", "switch", "(", "RegBankID", ")", "{", "case", "AArch64", "::", "GPRRegBankID", ":", "if", "(", "OpSize", "==", "32", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVWr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVWr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVWr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "else", "if", "(", "OpSize", "==", "64", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_PTR_ADD", ":", "return", "AArch64", "::", "ADDXrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVXr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVXr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVXr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "break", ";", "case", "AArch64", "::", "FPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDSrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBSrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULSrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVSrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDDrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBDrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULDrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVDrr", ";", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRv8i8", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "break", ";", "}", "return", "GenericOpc", ";", "}", "</s>" ]

[ "Select", "and", "emit", "code", "for", "a", "binary", "operator", "instruction", ",", "which", "has", "an", "opcode", "which", "directly", "corresponds", "to", "the", "given", "ISD", "opcode", "." ]

[ "AArch64", "AArch64::GPRRegBankID", "32", "AArch64::LSLVWr", "AArch64::LSRVWr", "AArch64::ASRVWr", "64", "AArch64::ADDXrr", "AArch64::LSLVXr", "AArch64::LSRVXr", "AArch64::ASRVXr", "AArch64::FPRRegBankID", "32", "AArch64::FADDSrr", "AArch64::FSUBSrr", "AArch64::FMULSrr", "AArch64::FDIVSrr", "64", "AArch64::FADDDrr", "AArch64::FSUBDrr", "AArch64::FMULDrr", "AArch64::FDIVDrr", "AArch64::ORRv8i8" ]

[]

[ "<s>", "static", "rtx", "frv_alloc_temp_reg", "(", "frv_tmp_reg_t", "*", "info", ",", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "int", "mark_as_used", ",", "int", "no_abort", ")", "{", "int", "regno", "=", "info", "->", "next_reg", "[", "(", "int", ")", "rclass", "]", ";", "int", "orig_regno", "=", "regno", ";", "HARD_REG_SET", "*", "reg_in_class", "=", "&", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ";", "int", "i", ",", "nr", ";", "for", "(", ";", ";", ")", "{", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "reg_in_class", ",", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", ")", ")", "break", ";", "if", "(", "++", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "0", ";", "if", "(", "regno", "==", "orig_regno", ")", "{", "gcc_assert", "(", "no_abort", ")", ";", "return", "NULL_RTX", ";", "}", "}", "nr", "=", "hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "info", "->", "next_reg", "[", "(", "int", ")", "rclass", "]", "=", "regno", "+", "nr", ";", "if", "(", "mark_as_used", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nr", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", "+", "i", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Return", "the", "next", "available", "temporary", "register", "in", "a", "given", "class", "." ]

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

[]

[ "<s>", "bool", "sparc_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "enum", "mode_class", "mclass1", ",", "mclass2", ";", "unsigned", "short", "size1", ",", "size2", ";", "if", "(", "mode1", "==", "mode2", ")", "return", "true", ";", "mclass1", "=", "GET_MODE_CLASS", "(", "mode1", ")", ";", "mclass2", "=", "GET_MODE_CLASS", "(", "mode2", ")", ";", "if", "(", "mclass1", "!=", "mclass2", ")", "return", "false", ";", "if", "(", "!", "TARGET_V9", ")", "return", "true", ";", "if", "(", "mclass1", "!=", "MODE_FLOAT", "&&", "mclass1", "!=", "MODE_VECTOR_INT", ")", "return", "true", ";", "size1", "=", "GET_MODE_SIZE", "(", "mode1", ")", ";", "size2", "=", "GET_MODE_SIZE", "(", "mode2", ")", ";", "if", "(", "(", "size1", ">", "4", "&&", "size2", "==", "4", ")", "||", "(", "size2", ">", "4", "&&", "size1", "==", "4", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "it", "is", "a", "good", "idea", "to", "tie", "two", "pseudo", "registers", "when", "one", "has", "mode", "MODE1", "and", "one", "has", "mode", "MODE2", ".", "If", "HARD_REGNO_MODE_OK", "could", "produce", "different", "values", "for", "MODE1", "and", "MODE2", ",", "for", "any", "hard", "reg", ",", "then", "this", "must", "be", "FALSE", "for", "correct", "output", ".", "For", "V9", "we", "have", "to", "deal", "with", "the", "fact", "that", "only", "the", "lower", "32", "floating", "point", "registers", "are", "32-bit", "addressable", "." ]

[ "sparc", "4", "4", "4", "4" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64", ":", "{", "assert", "(", "MFI", "->", "isVRegStackified", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return: $pop\"", "+", "utostr", "(", "MFI", "->", "getWARegStackId", "(", "MFI", "->", "getWAReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID", ":", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly::FALLTHROUGH_RETURN_I32", "WebAssembly::FALLTHROUGH_RETURN_I64", "WebAssembly::FALLTHROUGH_RETURN_F32", "WebAssembly::FALLTHROUGH_RETURN_F64", "0", "\"fallthrough-return: $pop\"", "0", "WebAssembly::FALLTHROUGH_RETURN_VOID", "\"fallthrough-return\"", "WebAssembly" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R31", ")", ".", "addReg", "(", "Alpha", "::", "R31", ")", ".", "addReg", "(", "Alpha", "::", "R31", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::BISr", "Alpha::R31", "Alpha::R31", "Alpha::R31" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32r1\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32r1\"", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"linux\"" ]

[]

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

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

[ "HSAIL", "\"HSAIL Assembly Printer\"" ]

[]

[ "<s>", "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "CMP", ")", ";", "OPCODE", "(", "UCMP", ")", ";", "OPCODE", "(", "BR_CCMASK", ")", ";", "OPCODE", "(", "SELECT_CCMASK", ")", ";", "OPCODE", "(", "ADJDYNALLOC", ")", ";", "OPCODE", "(", "EXTRACT_ACCESS", ")", ";", "OPCODE", "(", "UMUL_LOHI64", ")", ";", "OPCODE", "(", "SDIVREM64", ")", ";", "OPCODE", "(", "UDIVREM32", ")", ";", "OPCODE", "(", "UDIVREM64", ")", ";", "OPCODE", "(", "MVC", ")", ";", "OPCODE", "(", "ATOMIC_SWAPW", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_ADD", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_SUB", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_AND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_OR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_XOR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_NAND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MAX", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMAX", ")", ";", "OPCODE", "(", "ATOMIC_CMP_SWAPW", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "nios2_emit_stack_limit_check", "(", "void", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", ")", "emit_insn", "(", "gen_ctrapsi4", "(", "gen_rtx_LTU", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "stack_limit_rtx", ")", ",", "stack_pointer_rtx", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "else", "sorry", "(", "\"only register based stack limit is supported\"", ")", ";", "}", "</s>" ]

[ "Emit", "conditional", "trap", "for", "checking", "stack", "limit", "." ]

[ "nios2", "3", "\"only register based stack limit is supported\"" ]

[]

[ "<s>", "void", "GBZ80PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createGBZ80PostRAPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "GBZ80", "GB", "GB" ]

[]

[ "<s>", "void", "XCoreFrameInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "void", "M68kAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "ARM", "32" ]

[]

[ "<s>", "static", "void", "riscv_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "riscv_arg_info", "info", ";", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";", "cum", "->", "num_fprs", "=", "info", ".", "fpr_offset", "+", "info", ".", "num_fprs", ";", "cum", "->", "num_gprs", "=", "info", ".", "gpr_offset", "+", "info", ".", "num_gprs", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDSri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDLri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDUri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::I64RegClass", "VE::LDSri", "0", "VE::I32RegClass", "VE::LDLri", "0", "VE::F32RegClass", "VE::LDUri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "int", "GCNTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "T", "*", ">", "Args", ",", "FastMathFlags", "FMF", ",", "unsigned", "VF", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "intrinsicHasPackedVectorBenefit", "(", "ID", ")", ")", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Args", ",", "FMF", ",", "VF", ",", "I", ")", ";", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "RetTy", ")", ";", "if", "(", "!", "OrigTy", ".", "isSimple", "(", ")", ")", "{", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ID", ",", "RetTy", ",", "Args", ",", "FMF", ",", "VF", ",", "I", ")", ";", "}", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "unsigned", "NElts", "=", "LT", ".", "second", ".", "isVector", "(", ")", "?", "LT", ".", "second", ".", "getVectorNumElements", "(", ")", ":", "1", ";", "MVT", "::", "SimpleValueType", "SLT", "=", "LT", ".", "second", ".", "getScalarType", "(", ")", ".", "SimpleTy", ";", "if", "(", "SLT", "==", "MVT", "::", "f64", ")", "return", "LT", ".", "first", "*", "NElts", "*", "get64BitInstrCost", "(", ")", ";", "if", "(", "ST", "->", "has16BitInsts", "(", ")", "&&", "SLT", "==", "MVT", "::", "f16", ")", "NElts", "=", "(", "NElts", "+", "1", ")", "/", "2", ";", "unsigned", "InstRate", "=", "getQuarterRateInstrCost", "(", ")", ";", "if", "(", "ID", "==", "Intrinsic", "::", "fma", ")", "{", "InstRate", "=", "ST", "->", "hasFastFMAF32", "(", ")", "?", "getHalfRateInstrCost", "(", ")", ":", "getQuarterRateInstrCost", "(", ")", ";", "}", "return", "LT", ".", "first", "*", "NElts", "*", "InstRate", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "AMDGPU", "Intrinsic::ID", "1", "MVT::SimpleValueType", "MVT::f64", "MVT::f16", "1", "2", "Intrinsic::fma" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReturnBlock", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "0" ]

[]

[ "<s>", "int", "AMDGPUFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "OffsetBytes", "=", "2", "*", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "int", "UpperBound", "=", "FI", "==", "-", "1", "?", "MFI", "->", "getNumObjects", "(", ")", ":", "FI", ";", "for", "(", "int", "i", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "i", "<", "UpperBound", ";", "++", "i", ")", "{", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "i", ")", ")", ";", "OffsetBytes", "+=", "MFI", "->", "getObjectSize", "(", "i", ")", ";", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "4", ")", ";", "}", "if", "(", "FI", "!=", "-", "1", ")", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "OffsetBytes", "/", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AMDGPU", "AMDGPU", "2", "4", "1", "4", "1", "4" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "&", "DL", "=", "AP", ".", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "getOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "const", "char", "*", "pa_output_lbranch", "(", "rtx", "dest", ",", "rtx_insn", "*", "insn", ",", "int", "xdelay", ")", "{", "rtx", "xoperands", "[", "4", "]", ";", "xoperands", "[", "0", "]", "=", "dest", ";", "if", "(", "xdelay", "&&", "dbr_sequence_length", "(", ")", "!=", "0", ")", "{", "gcc_assert", "(", "!", "JUMP_P", "(", "NEXT_INSN", "(", "insn", ")", ")", ")", ";", "final_scan_insn", "(", "NEXT_INSN", "(", "insn", ")", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "NULL", ")", ";", "SET_INSN_DELETED", "(", "NEXT_INSN", "(", "insn", ")", ")", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "output_asm_insn", "(", "\"std %%r1,-16(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"std %%r1,-40(%%r30)\"", ",", "xoperands", ")", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "output_asm_insn", "(", "\"stw %%r1,-20(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"stw %%r1,-12(%%r30)\"", ",", "xoperands", ")", ";", "}", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0(%%r1),%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "xoperands", "[", "2", "]", "=", "xoperands", "[", "1", "]", ";", "pa_output_pic_pcrel_sequence", "(", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "output_asm_insn", "(", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "return", "\"ldd -16(%%r30),%%r1\"", ";", "else", "return", "\"ldd -40(%%r30),%%r1\"", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "return", "\"ldw -20(%%r30),%%r1\"", ";", "else", "return", "\"ldw -12(%%r30),%%r1\"", ";", "}", "}", "</s>" ]

[ "This", "routine", "handles", "output", "of", "long", "unconditional", "branches", "that", "exceed", "the", "maximum", "range", "of", "a", "simple", "branch", "instruction", ".", "Since", "we", "do", "n't", "have", "a", "register", "available", "for", "the", "branch", ",", "we", "save", "register", "%", "r1", "in", "the", "frame", "marker", ",", "load", "the", "branch", "destination", "DEST", "into", "%", "r1", ",", "execute", "the", "branch", ",", "and", "restore", "%", "r1", "in", "the", "delay", "slot", "of", "the", "branch", ".", "Since", "long", "branches", "may", "have", "an", "insn", "in", "the", "delay", "slot", "and", "the", "delay", "slot", "is", "used", "to", "restore", "%", "r1", ",", "we", "in", "general", "need", "to", "extract", "this", "insn", "and", "execute", "it", "before", "the", "branch", ".", "However", ",", "to", "facilitate", "use", "of", "this", "function", "by", "conditional", "branches", ",", "we", "also", "provide", "an", "option", "to", "not", "extract", "the", "delay", "insn", "so", "that", "it", "will", "be", "emitted", "after", "the", "long", "branch", ".", "So", ",", "if", "there", "is", "an", "insn", "in", "the", "delay", "slot", ",", "it", "is", "extracted", "if", "XDELAY", "is", "nonzero", ".", "The", "lengths", "of", "the", "various", "long-branch", "sequences", "are", "20", ",", "16", "and", "24", "bytes", "for", "the", "portable", "runtime", ",", "non-PIC", "and", "PIC", "cases", ",", "respectively", "." ]

[ "pa", "4", "0", "0", "0", "0", "2", "\"std %%r1,-16(%%r30)\"", "\"std %%r1,-40(%%r30)\"", "0", "2", "\"stw %%r1,-20(%%r30)\"", "\"stw %%r1,-12(%%r30)\"", "\"ldil L'%0,%%r1\"", "\"ldo R'%0(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "1", "1", "2", "1", "\"bv %%r0(%%r1)\"", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", "0", "2", "\"ldd -16(%%r30),%%r1\"", "\"ldd -40(%%r30),%%r1\"", "0", "2", "\"ldw -20(%%r30),%%r1\"", "\"ldw -12(%%r30),%%r1\"" ]

[]

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

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

[ "AArch64", "\"AArch64PreLegalizerCombiner\"" ]

[]

[ "<s>", "const", "char", "*", "thumb1_output_casesi", "(", "rtx", "*", "operands", ")", "{", "rtx", "diff_vec", "=", "PATTERN", "(", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "operands", "[", "0", "]", ")", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "diff_vec", ")", "==", "ADDR_DIFF_VEC", ")", ";", "switch", "(", "GET_MODE", "(", "diff_vec", ")", ")", "{", "case", "QImode", ":", "return", "(", "ADDR_DIFF_VEC_FLAGS", "(", "diff_vec", ")", ".", "offset_unsigned", "?", "\"bl\\t%___gnu_thumb1_case_uqi\"", ":", "\"bl\\t%___gnu_thumb1_case_sqi\"", ")", ";", "case", "HImode", ":", "return", "(", "ADDR_DIFF_VEC_FLAGS", "(", "diff_vec", ")", ".", "offset_unsigned", "?", "\"bl\\t%___gnu_thumb1_case_uhi\"", ":", "\"bl\\t%___gnu_thumb1_case_shi\"", ")", ";", "case", "SImode", ":", "return", "\"bl\\t%___gnu_thumb1_case_si\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "Thumb-1", "casesi", "dispatch", "sequence", "." ]

[ "arm", "0", "\"bl\\t%___gnu_thumb1_case_uqi\"", "\"bl\\t%___gnu_thumb1_case_sqi\"", "\"bl\\t%___gnu_thumb1_case_uhi\"", "\"bl\\t%___gnu_thumb1_case_shi\"", "\"bl\\t%___gnu_thumb1_case_si\"" ]

[]

[ "<s>", "void", "GCNTTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "CommonTTI", ".", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "peeling", "transformation", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "label_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "LABEL_REF_P", "(", "x", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "return", "0", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "label_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "label_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "LABEL_REF", "." ]

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

[]

[ "<s>", "static", "void", "add_pop_cfi_notes", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "high", ",", "unsigned", "int", "low", ")", "{", "rtx", "t", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "(", "high", "-", "low", "+", "1", ")", "*", "UNITS_PER_WORD", ")", ";", "t", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "t", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "t", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "for", "(", "unsigned", "int", "i", "=", "low", ";", "i", "<=", "high", ";", "i", "++", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "word_mode", ",", "i", ")", ")", ";", "}", "</s>" ]

[ "Create", "CFI", "notes", "for", "register", "pops", "." ]

[ "rx", "1", "1" ]

[]

[ "<s>", "uint32_t", "BTFDebug", "::", "addType", "(", "std", "::", "unique_ptr", "<", "BTFTypeBase", ">", "TypeEntry", ",", "const", "DIType", "*", "Ty", ")", "{", "TypeEntry", "->", "setId", "(", "TypeEntries", ".", "size", "(", ")", "+", "1", ")", ";", "uint32_t", "Id", "=", "TypeEntry", "->", "getId", "(", ")", ";", "DIToIdMap", "[", "Ty", "]", "=", "Id", ";", "TypeEntries", ".", "push_back", "(", "std", "::", "move", "(", "TypeEntry", ")", ")", ";", "return", "Id", ";", "}", "</s>" ]

[ "Add", "a", "new", "type", "attribute", "to", "the", "specified", "entity", "." ]

[ "BPF", "1" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "hasFP", "(", "MF", ")", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Split TFRCondSets\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Split TFRCondSets\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"PPC Lower MASS Entries\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PPC Lower MASS Entries\"" ]

[]

[ "<s>", "const", "SDValue", "&", "getMask", "(", ")", "const", "{", "return", "getOperand", "(", "3", ")", ";", "}", "</s>" ]

[ "Return", "the", "mask", "used", "by", "this", "recipe", "." ]

[ "X86", "3" ]

[]

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

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "void", "split_quadword_operands", "(", "rtx", "insn", ",", "enum", "rtx_code", "code", ",", "rtx", "*", "operands", ",", "rtx", "*", "low", ",", "int", "n", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "low", "[", "i", "]", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "i", "]", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", "==", "POST_INC", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ";", "operands", "[", "i", "]", "=", "low", "[", "i", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ";", "}", "else", "if", "(", "optimize_size", "&&", "MEM_P", "(", "operands", "[", "i", "]", ")", "&&", "REG_P", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", "&&", "(", "code", "!=", "MINUS", "||", "operands", "[", "1", "]", "!=", "const0_rtx", ")", "&&", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "REGNO", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", ")", ")", "{", "low", "[", "i", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", ")", ";", "operands", "[", "i", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", ";", "}", "else", "{", "low", "[", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "0", ",", "0", ",", "DImode", ")", ";", "operands", "[", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "1", ",", "0", ",", "DImode", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "is", "like", "nonimmediate_operand", "with", "a", "restriction", "on", "the", "type", "of", "MEM", "." ]

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

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "KILLGT", ")", "{", "return", "false", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "begin", "(", ")", "!=", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", "return", "false", ";", "return", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "==", "0", ";", "}", "else", "if", "(", "isVector", "(", "MI", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "AMDGPUInstrInfo", "::", "isPredicable", "(", "MI", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "AMDGPU", "R600", "AMDGPU::KILLGT", "AMDGPU::CF_ALU", "3", "0", "4", "0", "AMDGPU" ]

[]

[ "<s>", "Instruction", "*", "VETargetLowering", "::", "emitLeadingFence", "(", "IRBuilderBase", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "Release", ")", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "Inst", "->", "hasAtomicStore", "(", ")", ")", "return", "nullptr", ";", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "VE", "VE", "\"Invalid fence: unordered/non-atomic\"", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "bool", "WaitInsert", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "StrictFP", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "!", "X86", "::", "isX87Instruction", "(", "*", "MI", ")", ")", "continue", ";", "if", "(", "!", "(", "MI", "->", "mayRaiseFPException", "(", ")", "||", "MI", "->", "mayLoadOrStore", "(", ")", ")", "||", "isX87ControlInstruction", "(", "*", "MI", ")", ")", "continue", ";", "MachineBasicBlock", "::", "iterator", "AfterMI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "AfterMI", "!=", "MBB", ".", "end", "(", ")", "&&", "X86", "::", "isX87Instruction", "(", "*", "AfterMI", ")", "&&", "!", "isX87NonWaitingControlInstruction", "(", "*", "AfterMI", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "AfterMI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "WAIT", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nInsert wait after:\\t\"", "<<", "*", "MI", ")", ";", "++", "MI", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86::isX87Instruction", "X86::isX87Instruction", "X86::WAIT", "\"\\nInsert wait after:\\t\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "bool", "isCalleeStructRet", ",", "bool", "isCallerStructRet", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "*", "CallerF", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", "->", "getCallingConv", "(", ")", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "!", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "CCMatch", ")", "{", "bool", "R", "=", "(", "CallerCC", "==", "CallingConv", "::", "C", "||", "CallerCC", "==", "CallingConv", "::", "Fast", ")", ";", "bool", "E", "=", "(", "CalleeCC", "==", "CallingConv", "::", "C", "||", "CalleeCC", "==", "CallingConv", "::", "Fast", ")", ";", "if", "(", "!", "R", "||", "!", "E", ")", "return", "false", ";", "}", "if", "(", "isVarArg", ")", "return", "false", ";", "if", "(", "isCalleeStructRet", "||", "isCallerStructRet", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "Hexagon", "Hexagon", "ISD::OutputArg", "ISD::InputArg" ]

[]

[ "<s>", "static", "void", "darwin_rs6000_override_options", "(", "void", ")", "{", "rs6000_altivec_abi", "=", "1", ";", "TARGET_ALTIVEC_VRSAVE", "=", "1", ";", "rs6000_current_abi", "=", "ABI_DARWIN", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "TARGET_64BIT", ")", "darwin_one_byte_bool", "=", "1", ";", "if", "(", "TARGET_64BIT", "&&", "!", "TARGET_POWERPC64", ")", "{", "rs6000_isa_flags", "|=", "OPTION_MASK_POWERPC64", ";", "warning", "(", "0", ",", "\"%qs requires PowerPC64 architecture, enabling\"", ",", "\"-m64\"", ")", ";", "}", "if", "(", "TARGET_64BIT", ")", "rs6000_default_long_calls", "=", "0", ";", "if", "(", "flag_mkernel", ")", "{", "rs6000_default_long_calls", "=", "1", ";", "if", "(", "!", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_SOFT_FLOAT", ")", ")", "rs6000_isa_flags", "|=", "OPTION_MASK_SOFT_FLOAT", ";", "}", "if", "(", "!", "flag_mkernel", "&&", "!", "flag_apple_kext", "&&", "TARGET_64BIT", "&&", "!", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_ALTIVEC", ")", ")", "rs6000_isa_flags", "|=", "OPTION_MASK_ALTIVEC", ";", "if", "(", "!", "flag_mkernel", "&&", "!", "flag_apple_kext", "&&", "strverscmp", "(", "darwin_macosx_version_min", ",", "\"10.5\"", ")", ">=", "0", "&&", "!", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_ALTIVEC", ")", "&&", "!", "OPTION_SET_P", "(", "rs6000_cpu_index", ")", ")", "{", "rs6000_isa_flags", "|=", "OPTION_MASK_ALTIVEC", ";", "}", "}", "</s>" ]

[ "The", "Darwin", "version", "of", "SUBTARGET_OVERRIDE_OPTIONS", "." ]

[ "rs6000", "1", "1", "1", "0", "\"%qs requires PowerPC64 architecture, enabling\"", "\"-m64\"", "0", "1", "\"10.5\"", "0" ]

[]

[ "<s>", "static", "bool", "s390_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "TARGET_VX", "&&", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", ")", "return", "0", ";", "if", "(", "!", "satisfies_constraint_j00", "(", "op", ")", "&&", "!", "satisfies_constraint_jm1", "(", "op", ")", "&&", "!", "satisfies_constraint_jKK", "(", "op", ")", "&&", "!", "satisfies_constraint_jxx", "(", "op", ")", "&&", "!", "satisfies_constraint_jyy", "(", "op", ")", ")", "return", "0", ";", "}", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "1", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "mode", ")", ")", "return", "1", ";", "if", "(", "TLS_SYMBOLIC_CONST", "(", "op", ")", ")", "return", "0", ";", "if", "(", "flag_pic", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "s390", "16", "0", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "\"-\"", ":", "\"\"", ")", "+", "\"nan:0x\"", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "32", "?", "INT64_C", "(", "0x007fffff", ")", ":", "INT64_C", "(", "0x000fffffffffffff", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "128", ";", "char", "Buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "Buf", ",", "0", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "0", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "Buf", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"-\"", "\"\"", "\"nan:0x\"", "32", "0x007fffff", "0x000fffffffffffff", "128", "0", "0" ]

[]

[ "<s>", "static", "bool", "m68k_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "DATA_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "8", ")", "return", "true", ";", "}", "else", "if", "(", "ADDRESS_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "16", ")", "return", "true", ";", "}", "else", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "TARGET_FP_REG_SIZE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "On", "the", "68000", ",", "we", "let", "the", "cpu", "registers", "can", "hold", "any", "mode", ",", "but", "restrict", "the", "68881", "registers", "to", "floating-point", "modes", "." ]

[ "m68k", "4", "8", "4", "16" ]

[]

[ "<s>", "unsigned", "ARMMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "CTX", ".", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "Reg", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "RegNo", ";", "case", "ARM", "::", "Q0", ":", "case", "ARM", "::", "Q1", ":", "case", "ARM", "::", "Q2", ":", "case", "ARM", "::", "Q3", ":", "case", "ARM", "::", "Q4", ":", "case", "ARM", "::", "Q5", ":", "case", "ARM", "::", "Q6", ":", "case", "ARM", "::", "Q7", ":", "case", "ARM", "::", "Q8", ":", "case", "ARM", "::", "Q9", ":", "case", "ARM", "::", "Q10", ":", "case", "ARM", "::", "Q11", ":", "case", "ARM", "::", "Q12", ":", "case", "ARM", "::", "Q13", ":", "case", "ARM", "::", "Q14", ":", "case", "ARM", "::", "Q15", ":", "return", "2", "*", "RegNo", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::Q0", "ARM::Q1", "ARM::Q2", "ARM::Q3", "ARM::Q4", "ARM::Q5", "ARM::Q6", "ARM::Q7", "ARM::Q8", "ARM::Q9", "ARM::Q10", "ARM::Q11", "ARM::Q12", "ARM::Q13", "ARM::Q14", "ARM::Q15", "2", "32", "\"Unable to encode MCOperand!\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "RISCVRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "switch", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unrecognized ABI\"", ")", ";", "case", "RISCVABI", "::", "ABI_ILP32", ":", "case", "RISCVABI", "::", "ABI_LP64", ":", "return", "CSR_ILP32_LP64_RegMask", ";", "case", "RISCVABI", "::", "ABI_IL32PC64", ":", "case", "RISCVABI", "::", "ABI_L64PC128", ":", "return", "CSR_IL32PC64_L64PC128_RegMask", ";", "case", "RISCVABI", "::", "ABI_ILP32F", ":", "case", "RISCVABI", "::", "ABI_LP64F", ":", "return", "CSR_ILP32F_LP64F_RegMask", ";", "case", "RISCVABI", "::", "ABI_IL32PC64F", ":", "case", "RISCVABI", "::", "ABI_L64PC128F", ":", "return", "CSR_IL32PC64F_L64PC128F_RegMask", ";", "case", "RISCVABI", "::", "ABI_ILP32D", ":", "case", "RISCVABI", "::", "ABI_LP64D", ":", "return", "CSR_ILP32D_LP64D_RegMask", ";", "case", "RISCVABI", "::", "ABI_IL32PC64D", ":", "case", "RISCVABI", "::", "ABI_L64PC128D", ":", "return", "CSR_IL32PC64D_L64PC128D_RegMask", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"Unrecognized ABI\"", "RISCVABI::ABI_ILP32", "RISCVABI::ABI_LP64", "RISCVABI::ABI_IL32PC64", "RISCVABI::ABI_L64PC128", "RISCVABI::ABI_ILP32F", "RISCVABI::ABI_LP64F", "RISCVABI::ABI_IL32PC64F", "RISCVABI::ABI_L64PC128F", "RISCVABI::ABI_ILP32D", "RISCVABI::ABI_LP64D", "RISCVABI::ABI_IL32PC64D", "RISCVABI::ABI_L64PC128D" ]

[]

[ "<s>", "Register", "R600RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "R600", "::", "NoRegister", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600::NoRegister" ]

[]

[ "<s>", "const", "char", "*", "loongarch_output_order_conditional_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "inverted_p", ")", "{", "const", "char", "*", "branch", "[", "2", "]", ";", "if", "(", "operands", "[", "3", "]", "!=", "const0_rtx", ")", "{", "if", "(", "REGNO", "(", "operands", "[", "2", "]", ")", "==", "REGNO", "(", "operands", "[", "3", "]", ")", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "LT", ":", "case", "LTU", ":", "case", "GT", ":", "case", "GTU", ":", "inverted_p", "=", "!", "inverted_p", ";", "case", "LE", ":", "case", "LEU", ":", "case", "GE", ":", "case", "GEU", ":", "branch", "[", "!", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b\"", ",", "\"%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "\"\\t# branch never\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "LE", ":", "case", "LEU", ":", "case", "GT", ":", "case", "GTU", ":", "case", "LT", ":", "case", "LTU", ":", "case", "GE", ":", "case", "GEU", ":", "branch", "[", "!", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%C1\"", ",", "\"%2,%3,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%N1\"", ",", "\"%2,%3,%0\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "else", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "LEU", ":", "case", "GTU", ":", "case", "LTU", ":", "case", "GEU", ":", "case", "LE", ":", "case", "GT", ":", "case", "LT", ":", "case", "GE", ":", "branch", "[", "!", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%C1\"", ",", "\"%2,$r0,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "LARCH_BRANCH", "(", "\"b%N1\"", ",", "\"%2,$r0,%0\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "loongarch_output_conditional_branch", "(", "insn", ",", "operands", ",", "branch", "[", "1", "]", ",", "branch", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "code", "for", "INSN", ",", "which", "branches", "to", "OPERANDS", "[", "0", "]", "if", "some", "ordering", "condition", "is", "true", ".", "The", "condition", "is", "given", "by", "OPERANDS", "[", "1", "]", "if", "!", "INVERTED_P", ",", "otherwise", "it", "is", "the", "inverse", "of", "OPERANDS", "[", "1", "]", ".", "OPERANDS", "[", "2", "]", "is", "the", "comparison", "'s", "first", "operand", ";", "OPERANDS", "[", "3", "]", "is", "the", "second", "operand", "and", "may", "be", "zero", "or", "a", "register", "." ]

[ "loongarch", "2", "3", "2", "3", "1", "\"b\"", "\"%0\"", "\"\\t# branch never\"", "1", "\"b%C1\"", "\"%2,%3,%0\"", "\"b%N1\"", "\"%2,%3,%0\"", "1", "\"b%C1\"", "\"%2,$r0,%0\"", "\"b%N1\"", "\"%2,$r0,%0\"", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI annotate control flow\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI annotate control flow\"" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "Type", "*", "Int8PtrType", "=", "Type", "::", "getInt8PtrTy", "(", "TheModule", "->", "getContext", "(", ")", ")", ";", "SetJmp3", "=", "TheModule", "->", "getOrInsertFunction", "(", "\"_setjmp3\"", ",", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", ",", "{", "Int8PtrType", ",", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", "}", ",", "true", ")", ")", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "WinEHFuncInfo", "FuncInfo", ";", "addStateStores", "(", "F", ",", "FuncInfo", ")", ";", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "UseStackGuard", "=", "false", ";", "RegNode", "=", "nullptr", ";", "EHGuardNode", "=", "nullptr", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"_setjmp3\"", "\"no-frame-pointer-elim\"", "\"true\"" ]

[]

[ "<s>", "static", "bool", "pa_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "int", "precision", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "if", "(", "TARGET_64BIT", "&&", "mode", "==", "TImode", ")", "return", "true", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_INT", ":", "if", "(", "precision", "==", "CHAR_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "SHORT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "INT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_LONG_TYPE_SIZE", ")", "return", "true", ";", "return", "false", ";", "case", "MODE_FLOAT", ":", "if", "(", "precision", "==", "FLOAT_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "DOUBLE_TYPE_SIZE", ")", "return", "true", ";", "if", "(", "precision", "==", "LONG_DOUBLE_TYPE_SIZE", ")", "return", "true", ";", "return", "false", ";", "case", "MODE_DECIMAL_FLOAT", ":", "return", "false", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "True", "if", "MODE", "is", "valid", "for", "the", "target", ".", "By", "``", "valid", "''", ",", "we", "mean", "able", "to", "be", "manipulated", "in", "non-trivial", "ways", ".", "In", "particular", ",", "this", "means", "all", "the", "arithmetic", "is", "supported", "." ]

[ "pa" ]

[]

[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "if", "(", "Subtarget", ".", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "return", ";", "}", "const", "AMDGPUTargetLowering", "&", "Lowering", "=", "(", "*", "(", "const", "AMDGPUTargetLowering", "*", ")", "TLI", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "SDNode", "*", "Node", "=", "I", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "CopyToReg", ":", "{", "unsigned", "Reg", "=", "cast", "<", "RegisterSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getReg", "(", ")", ";", "SDValue", "Val", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getRegClass", "(", "Reg", ")", ";", "if", "(", "RC", "!=", "&", "AMDGPU", "::", "SReg_64RegClass", ")", "{", "continue", ";", "}", "if", "(", "!", "Val", ".", "getNode", "(", ")", "->", "isMachineOpcode", "(", ")", "||", "Val", ".", "getNode", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "continue", ";", "}", "const", "MCInstrDesc", "Desc", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "get", "(", "Val", ".", "getNode", "(", ")", "->", "getMachineOpcode", "(", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "RegInfo", "->", "setRegClass", "(", "Reg", ",", "TRI", "->", "getRegClass", "(", "Desc", ".", "OpInfo", "[", "0", "]", ".", "RegClass", ")", ")", ";", "continue", ";", "}", "}", "MachineSDNode", "*", "MachineNode", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "I", ")", ";", "if", "(", "!", "MachineNode", ")", "continue", ";", "SDNode", "*", "ResNode", "=", "Lowering", ".", "PostISelFolding", "(", "MachineNode", ",", "*", "CurDAG", ")", ";", "if", "(", "ResNode", "!=", "Node", ")", "{", "ReplaceUses", "(", "Node", ",", "ResNode", ")", ";", "}", "}", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "R600", "ISD::CopyToReg", "1", "2", "0" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr128", ":", "SPU", "::", "STQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr16", ":", "SPU", "::", "STQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr8", ":", "SPU", "::", "STQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "STQDv16i8", ":", "SPU", "::", "STQXv16i8", ";", "}", "else", "{", "assert", "(", "0", "&&", "\"Unknown regclass!\"", ")", ";", "abort", "(", ")", ";", "}", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::STQDr128", "SPU::STQXr128", "SPU::R64CRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R64FPRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R32CRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R32FPRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R16CRegisterClass", "SPU::STQDr16", "SPU::STQXr16", "SPU::R8CRegisterClass", "SPU::STQDr8", "SPU::STQXr8", "SPU::VECREGRegisterClass", "SPU::STQDv16i8", "SPU::STQXv16i8", "0", "\"Unknown regclass!\"" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "RV16K", "\"Expr shouldn't be null!\"" ]

[]

[ "<s>", "int64_t", "getRegNo", "(", ")", "const", "{", "return", "RegNo", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "isCortexA9", "(", ")", ")", "return", "false", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "Localizer", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "the", "(", "global", ")", "instruction", "selection", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "CAHPInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "CAHP", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CAHP", "::", "LW", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP::GPRRegClass", "\"Can't load this register from stack slot\"", "CAHP::LW", "0" ]

[]

[ "<s>", "void", "frv_expand_builtin_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "tree", "t", ";", "int", "num", "=", "cfun", "->", "args_info", "-", "FIRST_ARG_REGNUM", "-", "FRV_NUM_ARG_REGS", ";", "nextarg", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "GEN_INT", "(", "UNITS_PER_WORD", "*", "num", ")", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"va_start: args_info = %d, num = %d\\n\"", ",", "cfun", "->", "args_info", ",", "num", ")", ";", "debug_rtx", "(", "nextarg", ")", ";", "}", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "valist", ")", ",", "valist", ",", "make_tree", "(", "ptr_type_node", ",", "nextarg", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Expand", "__builtin_va_start", "to", "do", "the", "va_start", "macro", "." ]

[ "frv", "\"va_start: args_info = %d, num = %d\\n\"", "1" ]

[]

[ "<s>", "static", "void", "csky_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ",", "a_tramp", ";", "int", "pool", "=", "TRAMPOLINE_SIZE", "-", "8", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "pool", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "pool", "+", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "a_tramp", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "maybe_emit_call_builtin___clear_cache", "(", "a_tramp", ",", "plus_constant", "(", "Pmode", ",", "a_tramp", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "}", "</s>" ]

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

[ "csky", "0", "8", "4", "0" ]

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "VTMP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "P3_0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UGP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLELO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLEHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMELIMIT", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMEKEY", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "C8", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR_OVF", ")", ";", "for", "(", "int", "x", "=", "Reserved", ".", "find_first", "(", ")", ";", "x", ">=", "0", ";", "x", "=", "Reserved", ".", "find_next", "(", "x", ")", ")", "markSuperRegs", "(", "Reserved", ",", "x", ")", ";", "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", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::VTMP", "Hexagon::SA0", "Hexagon::LC0", "Hexagon::SA1", "Hexagon::LC1", "Hexagon::P3_0", "Hexagon::USR", "Hexagon::PC", "Hexagon::UGP", "Hexagon::GP", "Hexagon::CS0", "Hexagon::CS1", "Hexagon::UPCYCLELO", "Hexagon::UPCYCLEHI", "Hexagon::FRAMELIMIT", "Hexagon::FRAMEKEY", "Hexagon::PKTCOUNTLO", "Hexagon::PKTCOUNTHI", "Hexagon::UTIMERLO", "Hexagon::UTIMERHI", "Hexagon::C8", "Hexagon::USR_OVF", "0" ]

[]

[ "<s>", "void", "AVRShiftExpand", "::", "expand", "(", "BinaryOperator", "*", "BI", ")", "{", "auto", "&", "Ctx", "=", "BI", "->", "getContext", "(", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "BI", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ";", "Type", "*", "Int8Ty", "=", "Type", "::", "getInt8Ty", "(", "Ctx", ")", ";", "Value", "*", "Int8Zero", "=", "ConstantInt", "::", "get", "(", "Int8Ty", ",", "0", ")", ";", "BasicBlock", "*", "BB", "=", "BI", "->", "getParent", "(", ")", ";", "Function", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "BasicBlock", "*", "EndBB", "=", "BB", "->", "splitBasicBlock", "(", "BI", ",", "\"shift.done\"", ")", ";", "BasicBlock", "*", "LoopBB", "=", "BasicBlock", "::", "Create", "(", "Ctx", ",", "\"shift.loop\"", ",", "F", ",", "EndBB", ")", ";", "Builder", ".", "SetInsertPoint", "(", "&", "BB", "->", "back", "(", ")", ")", ";", "Value", "*", "ShiftAmount", "=", "Builder", ".", "CreateTrunc", "(", "BI", "->", "getOperand", "(", "1", ")", ",", "Int8Ty", ")", ";", "Value", "*", "Cmp1", "=", "Builder", ".", "CreateICmpEQ", "(", "ShiftAmount", ",", "Int8Zero", ")", ";", "Builder", ".", "CreateCondBr", "(", "Cmp1", ",", "EndBB", ",", "LoopBB", ")", ";", "BB", "->", "back", "(", ")", ".", "eraseFromParent", "(", ")", ";", "Builder", ".", "SetInsertPoint", "(", "LoopBB", ")", ";", "PHINode", "*", "ShiftAmountPHI", "=", "Builder", ".", "CreatePHI", "(", "Int8Ty", ",", "2", ")", ";", "ShiftAmountPHI", "->", "addIncoming", "(", "ShiftAmount", ",", "BB", ")", ";", "PHINode", "*", "ValuePHI", "=", "Builder", ".", "CreatePHI", "(", "Int32Ty", ",", "2", ")", ";", "ValuePHI", "->", "addIncoming", "(", "BI", "->", "getOperand", "(", "0", ")", ",", "BB", ")", ";", "Value", "*", "ShiftAmountSub", "=", "Builder", ".", "CreateSub", "(", "ShiftAmountPHI", ",", "ConstantInt", "::", "get", "(", "Int8Ty", ",", "1", ")", ")", ";", "ShiftAmountPHI", "->", "addIncoming", "(", "ShiftAmountSub", ",", "LoopBB", ")", ";", "Value", "*", "ValueShifted", ";", "switch", "(", "BI", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Shl", ":", "ValueShifted", "=", "Builder", ".", "CreateShl", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "case", "Instruction", "::", "LShr", ":", "ValueShifted", "=", "Builder", ".", "CreateLShr", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "case", "Instruction", "::", "AShr", ":", "ValueShifted", "=", "Builder", ".", "CreateAShr", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"asked to expand an instruction that is not a shift\"", ")", ";", "}", "ValuePHI", "->", "addIncoming", "(", "ValueShifted", ",", "LoopBB", ")", ";", "Value", "*", "Cmp2", "=", "Builder", ".", "CreateICmpEQ", "(", "ShiftAmountSub", ",", "Int8Zero", ")", ";", "Builder", ".", "CreateCondBr", "(", "Cmp2", ",", "EndBB", ",", "LoopBB", ")", ";", "Builder", ".", "SetInsertPoint", "(", "BI", ")", ";", "PHINode", "*", "Result", "=", "Builder", ".", "CreatePHI", "(", "Int32Ty", ",", "2", ")", ";", "Result", "->", "addIncoming", "(", "BI", "->", "getOperand", "(", "0", ")", ",", "BB", ")", ";", "Result", "->", "addIncoming", "(", "ValueShifted", ",", "LoopBB", ")", ";", "BI", "->", "replaceAllUsesWith", "(", "Result", ")", ";", "BI", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "expand", "-", "Expand", "a", "record", "into", "a", "set", "of", "elements", "if", "possible", "." ]

[ "AVR", "AVR", "0", "\"shift.done\"", "\"shift.loop\"", "1", "2", "2", "0", "1", "1", "1", "1", "\"asked to expand an instruction that is not a shift\"", "2", "0" ]

[]

[ "<s>", "bool", "WebAssembly", "::", "mayThrow", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "THROW", ":", "case", "WebAssembly", "::", "THROW_S", ":", "case", "WebAssembly", "::", "RETHROW", ":", "case", "WebAssembly", "::", "RETHROW_S", ":", "return", "true", ";", "}", "if", "(", "isCallIndirect", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "getCalleeOp", "(", "MI", ")", ";", "assert", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", ")", ";", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"memcpy\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memmove\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"memset\"", ")", "==", "0", ")", "return", "false", ";", "return", "true", ";", "}", "const", "auto", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "return", "true", ";", "if", "(", "F", "->", "doesNotThrow", "(", ")", ")", "return", "false", ";", "if", "(", "F", "->", "getName", "(", ")", "==", "CxaBeginCatchFn", "||", "F", "->", "getName", "(", ")", "==", "PersonalityWrapperFn", "||", "F", "->", "getName", "(", ")", "==", "StdTerminateFn", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "may", "throw", "an", "exception", "." ]

[ "WebAssembly", "WebAssembly::mayThrow", "WebAssembly::THROW", "WebAssembly::THROW_S", "WebAssembly::RETHROW", "WebAssembly::RETHROW_S", "\"memcpy\"", "0", "\"memmove\"", "0", "\"memset\"", "0" ]

[]

[ "<s>", "static", "unsigned", "ix86_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "!", "TARGET_ADJUST_UNROLL", ")", "return", "nunroll", ";", "subrtx_iterator", "::", "array_type", "array", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "const_rtx", "x", "=", "*", "iter", ")", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "unsigned", "int", "n_words", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "n_words", ">", "4", ")", "mem_count", "+=", "2", ";", "else", "mem_count", "+=", "1", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "&&", "mem_count", "<=", "32", ")", "return", "32", "/", "mem_count", ";", "return", "nunroll", ";", "}", "</s>" ]

[ "This", "function", "adjusts", "the", "unroll", "factor", "based", "on", "the", "hardware", "capabilities", ".", "For", "ex", ",", "bdver3", "has", "a", "loop", "buffer", "which", "makes", "unrolling", "of", "smaller", "loops", "less", "important", ".", "This", "function", "decides", "the", "unroll", "factor", "using", "number", "of", "memory", "references", "(", "value", "32", "is", "used", ")", "as", "a", "heuristic", "." ]

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

[]