Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "pass_vsetvl", "::", "forward_demand_fusion", "(", "void", ")", "{", "bool", "changed_p", "=", "false", ";", "for", "(", "const", "bb_info", "*", "bb", ":", "crtl", "->", "ssa", "->", "bbs", "(", ")", ")", "{", "basic_block", "cfg_bb", "=", "bb", "->", "cfg_bb", "(", ")", ";", "const", "auto", "&", "prop", "=", "m_vector_manager", "->", "vector_block_infos", "[", "cfg_bb", "->", "index", "]", ".", "reaching_out", ";", "if", "(", "!", "prop", ".", "valid_or_dirty_p", "(", ")", ")", "continue", ";", "if", "(", "cfg_bb", "==", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "continue", ";", "if", "(", "vsetvl_insn_p", "(", "prop", ".", "get_insn", "(", ")", "->", "rtl", "(", ")", ")", ")", "continue", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "cfg_bb", "->", "succs", ")", "{", "auto", "&", "local_dem", "=", "m_vector_manager", "->", "vector_block_infos", "[", "e", "->", "dest", "->", "index", "]", ".", "local_dem", ";", "auto", "&", "reaching_out", "=", "m_vector_manager", "->", "vector_block_infos", "[", "e", "->", "dest", "->", "index", "]", ".", "reaching_out", ";", "if", "(", "e", "->", "dest", "->", "index", "==", "cfg_bb", "->", "index", ")", "continue", ";", "if", "(", "e", "->", "flags", "&", "EDGE_COMPLEX", ")", "continue", ";", "if", "(", "e", "->", "dest", "->", "index", "==", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "index", ")", "continue", ";", "if", "(", "!", "local_dem", ".", "valid_or_dirty_p", "(", ")", ")", "continue", ";", "if", "(", "local_dem", ".", "available_p", "(", "prop", ")", ")", "continue", ";", "if", "(", "!", "local_dem", ".", "compatible_p", "(", "prop", ")", ")", "continue", ";", "if", "(", "propagate_avl_across_demands_p", "(", "prop", ",", "local_dem", ")", ")", "continue", ";", "vector_insn_info", "new_info", "=", "local_dem", ".", "merge", "(", "prop", ",", "GLOBAL_MERGE", ")", ";", "new_info", ".", "set_insn", "(", "local_dem", ".", "get_insn", "(", ")", ")", ";", "if", "(", "local_dem", ".", "dirty_p", "(", ")", ")", "{", "gcc_assert", "(", "local_dem", "==", "reaching_out", ")", ";", "new_info", ".", "set_dirty", "(", "local_dem", ".", "dirty_with_killed_avl_p", "(", ")", ")", ";", "local_dem", "=", "new_info", ";", "reaching_out", "=", "local_dem", ";", "}", "else", "{", "if", "(", "reaching_out", "==", "local_dem", ")", "reaching_out", "=", "new_info", ";", "local_dem", "=", "new_info", ";", "change_vsetvl_insn", "(", "local_dem", ".", "get_insn", "(", ")", ",", "new_info", ")", ";", "}", "auto", "&", "prob", "=", "m_vector_manager", "->", "vector_block_infos", "[", "e", "->", "dest", "->", "index", "]", ".", "probability", ";", "auto", "&", "curr_prob", "=", "m_vector_manager", "->", "vector_block_infos", "[", "cfg_bb", "->", "index", "]", ".", "probability", ";", "prob", "=", "curr_prob", "*", "e", "->", "probability", ";", "changed_p", "=", "true", ";", "}", "}", "return", "changed_p", ";", "}", "</s>" ]

[ "Compute", "global", "forward", "demanded", "info", "." ]

[ "riscv" ]

[]

[ "<s>", "VESubtarget", "&", "VESubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"ve\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "\"ve\"" ]

[]

[ "<s>", "void", "arm_print_tune_info", "(", "void", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\"", "ASM_COMMENT_START", "\".tune parameters\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"constant_limit:\\t%d\\n\"", ",", "current_tune", "->", "constant_limit", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"max_insns_skipped:\\t%d\\n\"", ",", "current_tune", "->", "max_insns_skipped", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefetch.num_slots:\\t%d\\n\"", ",", "current_tune", "->", "prefetch", ".", "num_slots", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefetch.l1_cache_size:\\t%d\\n\"", ",", "current_tune", "->", "prefetch", ".", "l1_cache_size", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefetch.l1_cache_line_size:\\t%d\\n\"", ",", "current_tune", "->", "prefetch", ".", "l1_cache_line_size", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefer_constant_pool:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_constant_pool", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"branch_cost:\\t(s:speed, p:predictable)\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"\\t\\ts&p\\tcost\\n\"", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"\\t\\t00\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "false", ",", "false", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"\\t\\t01\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "false", ",", "true", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"\\t\\t10\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "true", ",", "false", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"\\t\\t11\\t%d\\n\"", ",", "current_tune", "->", "branch_cost", "(", "true", ",", "true", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefer_ldrd_strd:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_ldrd_strd", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"logical_op_non_short_circuit:\\t[%d,%d]\\n\"", ",", "(", "int", ")", "current_tune", "->", "logical_op_non_short_circuit_thumb", ",", "(", "int", ")", "current_tune", "->", "logical_op_non_short_circuit_arm", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"prefer_neon_for_64bits:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "prefer_neon_for_64bits", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"disparage_flag_setting_t16_encodings:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "disparage_flag_setting_t16_encodings", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"string_ops_prefer_neon:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "string_ops_prefer_neon", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"max_insns_inline_memset:\\t%d\\n\"", ",", "current_tune", "->", "max_insns_inline_memset", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"fusible_ops:\\t%u\\n\"", ",", "current_tune", "->", "fusible_ops", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t\\t\"", "ASM_COMMENT_START", "\"sched_autopref:\\t%d\\n\"", ",", "(", "int", ")", "current_tune", "->", "sched_autopref", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "print", "CPU", "tuning", "information", "as", "comment", "in", "assembler", "file", ".", "Pointers", "are", "not", "printed", "for", "now", "." ]

[ "arm", "\"\\t\"", "\".tune parameters\\n\"", "\"\\t\\t\"", "\"constant_limit:\\t%d\\n\"", "\"\\t\\t\"", "\"max_insns_skipped:\\t%d\\n\"", "\"\\t\\t\"", "\"prefetch.num_slots:\\t%d\\n\"", "\"\\t\\t\"", "\"prefetch.l1_cache_size:\\t%d\\n\"", "\"\\t\\t\"", "\"prefetch.l1_cache_line_size:\\t%d\\n\"", "\"\\t\\t\"", "\"prefer_constant_pool:\\t%d\\n\"", "\"\\t\\t\"", "\"branch_cost:\\t(s:speed, p:predictable)\\n\"", "\"\\t\\t\"", "\"\\t\\ts&p\\tcost\\n\"", "\"\\t\\t\"", "\"\\t\\t00\\t%d\\n\"", "\"\\t\\t\"", "\"\\t\\t01\\t%d\\n\"", "\"\\t\\t\"", "\"\\t\\t10\\t%d\\n\"", "\"\\t\\t\"", "\"\\t\\t11\\t%d\\n\"", "\"\\t\\t\"", "\"prefer_ldrd_strd:\\t%d\\n\"", "\"\\t\\t\"", "\"logical_op_non_short_circuit:\\t[%d,%d]\\n\"", "\"\\t\\t\"", "\"prefer_neon_for_64bits:\\t%d\\n\"", "\"\\t\\t\"", "\"disparage_flag_setting_t16_encodings:\\t%d\\n\"", "\"\\t\\t\"", "\"string_ops_prefer_neon:\\t%d\\n\"", "\"\\t\\t\"", "\"max_insns_inline_memset:\\t%d\\n\"", "\"\\t\\t\"", "\"fusible_ops:\\t%u\\n\"", "\"\\t\\t\"", "\"sched_autopref:\\t%d\\n\"" ]

[]

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

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

[ "P2" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ")", "const", "{", "unsigned", "SrcSize", "=", "SrcRC", "->", "getSize", "(", ")", ";", "unsigned", "DstSize", "=", "DstRC", "->", "getSize", "(", ")", ";", "unsigned", "NewSize", "=", "NewRC", "->", "getSize", "(", ")", ";", "if", "(", "SrcSize", "<=", "4", "||", "DstSize", "<=", "4", ")", "return", "true", ";", "return", "NewSize", "<=", "DstSize", "||", "NewSize", "<=", "SrcSize", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "X86MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "frv_print_operand_address", "(", "FILE", "*", "stream", ",", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "stream", ")", ";", "return", ";", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "\"%ld\"", ",", "(", "long", ")", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "assemble_name", "(", "stream", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "case", "CONST", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "return", ";", "case", "PLUS", ":", "frv_print_operand_memory_reference", "(", "stream", ",", "x", ",", "0", ")", ";", "return", ";", "default", ":", "break", ";", "}", "fatal_insn", "(", "\"bad insn to frv_print_operand_address:\"", ",", "x", ")", ";", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "frv", "0", "\"%ld\"", "0", "0", "\"bad insn to frv_print_operand_address:\"" ]

[]

[ "<s>", "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "A1_64", ":", "Mips", "::", "A1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "Mips", "Mips::A1_64", "Mips::A1" ]

[]

[ "<s>", "static", "void", "check_store_cacheline_hazard", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ",", "*", "insn1", ";", "bool", "found", "=", "false", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "arc_active_insn", "(", "insn", ")", ")", "{", "succ0", "=", "arc_active_insn", "(", "insn", ")", ";", "if", "(", "!", "succ0", ")", "return", ";", "if", "(", "!", "single_set", "(", "insn", ")", ")", "continue", ";", "if", "(", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_STORE", ")", ")", "continue", ";", "for", "(", "insn1", "=", "succ0", ";", "insn1", ";", "insn1", "=", "arc_active_insn", "(", "insn1", ")", ")", "if", "(", "!", "single_set", "(", "insn1", ")", "||", "get_attr_type", "(", "insn1", ")", "!=", "TYPE_STORE", ")", "break", ";", "succ0", "=", "insn1", ";", "if", "(", "insn1", "&&", "single_set", "(", "insn1", ")", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_LOAD", ")", ")", "{", "found", "=", "true", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "}", "else", "{", "if", "(", "insn1", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_COMPARE", ")", ")", "{", "add_reg_note", "(", "insn1", ",", "REG_SAVE_NOTE", ",", "GEN_INT", "(", "3", ")", ")", ";", "}", "insn1", "=", "arc_active_insn", "(", "insn1", ")", ";", "if", "(", "insn1", "&&", "single_set", "(", "insn1", ")", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_LOAD", ")", ")", "{", "found", "=", "true", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "}", "}", "if", "(", "found", ")", "{", "insn", "=", "insn1", ";", "found", "=", "false", ";", "}", "else", "insn", "=", "succ0", ";", "}", "}", "</s>" ]

[ "Search", "for", "a", "sequence", "made", "out", "of", "two", "stores", "and", "a", "given", "number", "of", "loads", ",", "insert", "a", "nop", "if", "required", "." ]

[ "arc", "3" ]

[]

[ "<s>", "static", "rtx", "moxie_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fntype_or_decl", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "MOXIE_R0", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "We", "always", "return", "values", "in", "register", "$", "r0", "for", "moxie", "." ]

[ "moxie" ]

[]

[ "<s>", "bool", "ThunkInserter", "<", "Derived", ">", "::", "run", "(", "MachineModuleInfo", "&", "MMI", ",", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "getDerived", "(", ")", ".", "getThunkPrefix", "(", ")", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "!", "getDerived", "(", ")", ".", "mayUseThunk", "(", "MF", ")", ")", "return", "false", ";", "getDerived", "(", ")", ".", "insertThunks", "(", "MMI", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "getDerived", "(", ")", ".", "populateThunk", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "X86" ]

[]

[ "<s>", "unsigned", "CFStack", "::", "getLoopDepth", "(", ")", "{", "return", "LoopStack", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "loop", "nesting", "level", "of", "the", "specified", "block", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "{", "SDValue", "Ops", "[", "2", "]", ";", "std", "::", "tie", "(", "Ops", "[", "0", "]", ",", "Ops", "[", "1", "]", ")", "=", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "getSplitDestVTs", "(", "VT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "getSplitDestVTs", "(", "MemVT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "splitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ",", "DAG", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "SL", ",", "BasePtr", ",", "Size", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "Join", ";", "if", "(", "LoVT", "==", "HiVT", ")", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ";", "}", "else", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "SL", ",", "VT", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "LoLoad", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "SL", ")", ")", ";", "Join", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "INSERT_SUBVECTOR", ":", "ISD", "::", "INSERT_VECTOR_ELT", ",", "SL", ",", "VT", ",", "Join", ",", "HiLoad", ",", "DAG", ".", "getVectorIdxConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "SL", ")", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Join", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "2", "0", "1", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "0", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "void", "s390_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"floatAbi\"", ",", "s390_d_handle_target_float_abi", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_CPU_TARGET_INFO", "." ]

[ "s390", "\"floatAbi\"" ]

[]

[ "<s>", "int", "m32c_reg_ok_for_base_p", "(", "rtx", "x", ",", "int", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "REG", ")", "return", "0", ";", "switch", "(", "REGNO", "(", "x", ")", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "case", "FB_REGNO", ":", "case", "SP_REGNO", ":", "return", "1", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "x", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "</s>" ]

[ "Implements", "REG_OK_FOR_BASE_P", "." ]

[ "m32c", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.word\\tgs(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "PSImode", ")", "{", "fputs", "(", "\"\\t.byte\\tlo8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thi8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thh8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "CONST_FIXED_P", "(", "x", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "<", "size", ";", "n", "++", ")", "{", "rtx", "xn", "=", "simplify_gen_subreg", "(", "QImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "n", ")", ";", "default_assemble_integer", "(", "xn", ",", "1", ",", "aligned_p", ")", ";", "}", "return", "true", ";", "}", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_pm_p", "(", "x", ")", ")", "{", "x", "=", "plus_constant", "(", "Pmode", ",", "x", ",", "AVR_TINY_PM_OFFSET", ")", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "." ]

[ "avr", "\"\\t.word\\tgs(\"", "\")\\n\"", "\"\\t.byte\\tlo8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thi8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thh8(\"", "\")\"", "\"need binutils PR13503\\n\"", "0", "1" ]

[]

[ "<s>", "TPCAAResult", "run", "(", "Function", "&", "F", ",", "AnalysisManager", "<", "Function", ">", "&", "AM", ")", "{", "return", "TPCAAResult", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "TPC", "TPC", "TPC" ]

[]

[ "<s>", "bool", "ARM64PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createARM64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createARM64LoadStoreOptimizationPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "static", "int", "arm_save_coproc_regs", "(", "void", ")", "{", "int", "saved_size", "=", "0", ";", "unsigned", "reg", ";", "unsigned", "start_reg", ";", "rtx", "insn", ";", "for", "(", "reg", "=", "LAST_IWMMXT_REGNUM", ";", "reg", ">=", "FIRST_IWMMXT_REGNUM", ";", "reg", "--", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "{", "insn", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "insn", "=", "gen_rtx_MEM", "(", "V2SImode", ",", "insn", ")", ";", "insn", "=", "emit_set_insn", "(", "insn", ",", "gen_rtx_REG", "(", "V2SImode", ",", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "saved_size", "+=", "8", ";", "}", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", ")", "{", "start_reg", "=", "FIRST_VFP_REGNUM", ";", "for", "(", "reg", "=", "FIRST_VFP_REGNUM", ";", "reg", "<", "LAST_VFP_REGNUM", ";", "reg", "+=", "2", ")", "{", "if", "(", "(", "!", "df_regs_ever_live_p", "(", "reg", ")", "||", "call_used_regs", "[", "reg", "]", ")", "&&", "(", "!", "df_regs_ever_live_p", "(", "reg", "+", "1", ")", "||", "call_used_regs", "[", "reg", "+", "1", "]", ")", ")", "{", "if", "(", "start_reg", "!=", "reg", ")", "saved_size", "+=", "vfp_emit_fstmd", "(", "start_reg", ",", "(", "reg", "-", "start_reg", ")", "/", "2", ")", ";", "start_reg", "=", "reg", "+", "2", ";", "}", "}", "if", "(", "start_reg", "!=", "reg", ")", "saved_size", "+=", "vfp_emit_fstmd", "(", "start_reg", ",", "(", "reg", "-", "start_reg", ")", "/", "2", ")", ";", "}", "return", "saved_size", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "save", "coprocessor", "registers", "on", "function", "entry", ".", "Returns", "the", "number", "of", "bytes", "pushed", "." ]

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

[]

[ "<s>", "void", "XtensaInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented operand\"", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"Unimplemented operand\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_vectorize_preferred_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "aarch64_sve_data_mode_p", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "{", "HOST_WIDE_INT", "result", ";", "if", "(", "!", "BITS_PER_SVE_VECTOR", ".", "is_constant", "(", "&", "result", ")", ")", "result", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "return", "result", ";", "}", "return", "TYPE_ALIGN", "(", "type", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "AArch64MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "Ctx", ".", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unable to encode MCOperand!\"", "0" ]

[]

[ "<s>", "void", "PPCScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "MCInstrDesc", "*", "MCID", "=", "DAG", "->", "getInstrDesc", "(", "SU", ")", ";", "if", "(", "!", "MCID", ")", "return", ";", "ScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Ops", ")", "{", "const", "MCRegisterInfo", "*", "MRI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "VMOVZPQILo2PQIrr", ":", "case", "X86", "::", "VMOVAPDrr", ":", "case", "X86", "::", "VMOVAPDYrr", ":", "case", "X86", "::", "VMOVAPSrr", ":", "case", "X86", "::", "VMOVAPSYrr", ":", "case", "X86", "::", "VMOVDQArr", ":", "case", "X86", "::", "VMOVDQAYrr", ":", "case", "X86", "::", "VMOVDQUrr", ":", "case", "X86", "::", "VMOVDQUYrr", ":", "case", "X86", "::", "VMOVUPDrr", ":", "case", "X86", "::", "VMOVUPDYrr", ":", "case", "X86", "::", "VMOVUPSrr", ":", "case", "X86", "::", "VMOVUPSYrr", ":", "{", "if", "(", "ForcedVEXEncoding", "==", "VEXEncoding_VEX3", "||", "MRI", "->", "getEncodingValue", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ">=", "8", "||", "MRI", "->", "getEncodingValue", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "<", "8", ")", "return", "false", ";", "unsigned", "NewOpc", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode\"", ")", ";", "case", "X86", "::", "VMOVZPQILo2PQIrr", ":", "NewOpc", "=", "X86", "::", "VMOVPQI2QIrr", ";", "break", ";", "case", "X86", "::", "VMOVAPDrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPDYrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPDYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPSrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPSrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVAPSYrr", ":", "NewOpc", "=", "X86", "::", "VMOVAPSYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQArr", ":", "NewOpc", "=", "X86", "::", "VMOVDQArr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQAYrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQAYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQUrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQUrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVDQUYrr", ":", "NewOpc", "=", "X86", "::", "VMOVDQUYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPDrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPDYrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPDYrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPSrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPSrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVUPSYrr", ":", "NewOpc", "=", "X86", "::", "VMOVUPSYrr_REV", ";", "break", ";", "}", "Inst", ".", "setOpcode", "(", "NewOpc", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "VMOVSDrr", ":", "case", "X86", "::", "VMOVSSrr", ":", "{", "if", "(", "ForcedVEXEncoding", "==", "VEXEncoding_VEX3", "||", "MRI", "->", "getEncodingValue", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ">=", "8", "||", "MRI", "->", "getEncodingValue", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "<", "8", ")", "return", "false", ";", "unsigned", "NewOpc", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode\"", ")", ";", "case", "X86", "::", "VMOVSDrr", ":", "NewOpc", "=", "X86", "::", "VMOVSDrr_REV", ";", "break", ";", "case", "X86", "::", "VMOVSSrr", ":", "NewOpc", "=", "X86", "::", "VMOVSSrr_REV", ";", "break", ";", "}", "Inst", ".", "setOpcode", "(", "NewOpc", ")", ";", "return", "true", ";", "}", "}", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "X86", "X86", "X86::VMOVZPQILo2PQIrr", "X86::VMOVAPDrr", "X86::VMOVAPDYrr", "X86::VMOVAPSrr", "X86::VMOVAPSYrr", "X86::VMOVDQArr", "X86::VMOVDQAYrr", "X86::VMOVDQUrr", "X86::VMOVDQUYrr", "X86::VMOVUPDrr", "X86::VMOVUPDYrr", "X86::VMOVUPSrr", "X86::VMOVUPSYrr", "0", "8", "1", "8", "\"Invalid opcode\"", "X86::VMOVZPQILo2PQIrr", "X86::VMOVPQI2QIrr", "X86::VMOVAPDrr", "X86::VMOVAPDrr_REV", "X86::VMOVAPDYrr", "X86::VMOVAPDYrr_REV", "X86::VMOVAPSrr", "X86::VMOVAPSrr_REV", "X86::VMOVAPSYrr", "X86::VMOVAPSYrr_REV", "X86::VMOVDQArr", "X86::VMOVDQArr_REV", "X86::VMOVDQAYrr", "X86::VMOVDQAYrr_REV", "X86::VMOVDQUrr", "X86::VMOVDQUrr_REV", "X86::VMOVDQUYrr", "X86::VMOVDQUYrr_REV", "X86::VMOVUPDrr", "X86::VMOVUPDrr_REV", "X86::VMOVUPDYrr", "X86::VMOVUPDYrr_REV", "X86::VMOVUPSrr", "X86::VMOVUPSrr_REV", "X86::VMOVUPSYrr", "X86::VMOVUPSYrr_REV", "X86::VMOVSDrr", "X86::VMOVSSrr", "0", "8", "2", "8", "\"Invalid opcode\"", "X86::VMOVSDrr", "X86::VMOVSDrr_REV", "X86::VMOVSSrr", "X86::VMOVSSrr_REV" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2LDRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "void", "CompositeHandler", "::", "visitCallInst", "(", "CallInst", "&", "I", ")", "{", "for", "(", "Value", "*", "Arg", ":", "I", ".", "arg_operands", "(", ")", ")", "{", "visitValue", "(", "Arg", ",", "Arg", "->", "getType", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "CallInst", "simplification", "." ]

[ "JVM" ]

[]

[ "<s>", "tree", "arm_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "if", "(", "!", "arm_valid_target_attribute_rec", "(", "args", ",", "opts", ")", ")", "return", "NULL_TREE", ";", "arm_option_override_internal", "(", "opts", ",", "opts_set", ")", ";", "return", "build_target_option_node", "(", "opts", ")", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

[ "arm" ]

[]

[ "<s>", "void", "TPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createTPCScalarSink", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addBlockPlacement", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", ")", "{", "addPass", "(", "createTPCImmToReg", "(", ")", ")", ";", "addPass", "(", "createTPCAddrOpt", "(", ")", ")", ";", "addPass", "(", "createTPCRegisterBalancer", "(", ")", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "createTPCHardwareLoops", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCPipeliner", "(", ")", ",", "false", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "createTPCSubregInitElimination", "(", ")", ")", ";", "}", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createTPCHWWAGeneral", "(", ")", ")", ";", "addPass", "(", "createTPCHWWA2", "(", ")", ")", ";", "addPass", "(", "createTPCPreRAHwWorkarounds", "(", ")", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "static", "const", "char", "*", "pru_comparison_str", "(", "enum", "rtx_code", "cond", ")", "{", "switch", "(", "cond", ")", "{", "case", "NE", ":", "return", "\"ne\"", ";", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "GEU", ":", "return", "\"ge\"", ";", "case", "GTU", ":", "return", "\"gt\"", ";", "case", "LEU", ":", "return", "\"le\"", ";", "case", "LTU", ":", "return", "\"lt\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Map", "rtx_code", "to", "unsigned", "PRU", "branch", "op", "suffix", ".", "Callers", "must", "handle", "sign", "comparison", "themselves", "for", "signed", "operations", "." ]

[ "pru", "\"ne\"", "\"eq\"", "\"ge\"", "\"gt\"", "\"le\"", "\"lt\"" ]

[]

[ "<s>", "MachineInstr", "*", "AMDGPUInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MFI", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "return", "NULL", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "MachineFrameInfo", "*", "MFI", "=", "CurDAG", "->", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "SDValue", "FI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "I", ",", "MVT", "::", "i32", ")", ";", "if", "(", "FI", ".", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "EffectiveFI", "=", "FI", ";", "auto", "It", "=", "FI", "->", "use_begin", "(", ")", ";", "if", "(", "It", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AssertZext", "&&", "FI", "->", "hasOneUse", "(", ")", ")", "{", "EffectiveFI", "=", "SDValue", "(", "*", "It", ",", "0", ")", ";", "It", "=", "EffectiveFI", "->", "use_begin", "(", ")", ";", "}", "for", "(", "auto", "It", "=", "EffectiveFI", "->", "use_begin", "(", ")", ";", "!", "It", ".", "atEnd", "(", ")", ";", ")", "{", "SDUse", "&", "Use", "=", "It", ".", "getUse", "(", ")", ";", "SDNode", "*", "User", "=", "Use", ".", "getUser", "(", ")", ";", "unsigned", "OpIdx", "=", "It", ".", "getOperandNo", "(", ")", ";", "++", "It", ";", "if", "(", "MemSDNode", "*", "M", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "User", ")", ")", "{", "unsigned", "PtrIdx", "=", "M", "->", "getOpcode", "(", ")", "==", "ISD", "::", "STORE", "?", "2", ":", "1", ";", "if", "(", "OpIdx", "==", "PtrIdx", ")", "continue", ";", "unsigned", "OpN", "=", "M", "->", "getNumOperands", "(", ")", ";", "SDValue", "NewOps", "[", "8", "]", ";", "assert", "(", "OpN", "<", "array_lengthof", "(", "NewOps", ")", ")", ";", "for", "(", "unsigned", "Op", "=", "0", ";", "Op", "!=", "OpN", ";", "++", "Op", ")", "{", "if", "(", "Op", "!=", "OpIdx", ")", "{", "NewOps", "[", "Op", "]", "=", "M", "->", "getOperand", "(", "Op", ")", ";", "continue", ";", "}", "MachineSDNode", "*", "Mov", "=", "CurDAG", "->", "getMachineNode", "(", "AMDGPU", "::", "V_MOV_B32_e32", ",", "SDLoc", "(", "M", ")", ",", "MVT", "::", "i32", ",", "FI", ")", ";", "NewOps", "[", "Op", "]", "=", "SDValue", "(", "Mov", ",", "0", ")", ";", "}", "CurDAG", "->", "UpdateNodeOperands", "(", "M", ",", "makeArrayRef", "(", "NewOps", ",", "OpN", ")", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "AMDGPU", "AMDGPU", "MVT::i32", "ISD::AssertZext", "0", "ISD::STORE", "2", "1", "8", "0", "AMDGPU::V_MOV_B32_e32", "MVT::i32", "0" ]

[]

[ "<s>", "static", "bool", "mips_load_call_address", "(", "enum", "mips_call_type", "type", ",", "rtx", "dest", ",", "rtx", "addr", ")", "{", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "!", "(", "type", "==", "MIPS_CALL_SIBCALL", "&&", "TARGET_CALL_SAVED_GP", ")", "&&", "mips_ok_for_lazy_binding_p", "(", "addr", ")", ")", "{", "addr", "=", "mips_got_load", "(", "dest", ",", "addr", ",", "SYMBOL_GOTOFF_CALL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "addr", ")", ")", ";", "return", "true", ";", "}", "else", "{", "mips_emit_move", "(", "dest", ",", "addr", ")", ";", "return", "false", ";", "}", "}", "</s>" ]

[ "Load", "function", "address", "ADDR", "into", "register", "DEST", ".", "SIBCALL_P", "is", "true", "if", "the", "address", "is", "needed", "for", "a", "sibling", "call", "." ]

[ "mips" ]

[]

[ "<s>", "MCGNodes", "&", "getNodes", "(", ")", "{", "return", "MCG", ".", "getNodes", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "list", "of", "nodes", "in", "this", "pi-block", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "rvexTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "rvexSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "rvexSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isLinux", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "rvex", "rvex" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "Opcode", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "return", "false", ";", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "MRI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" C++ instruction selection: \"", ";", "I", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "selectLoadStoreOp", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "case", "TargetOpcode", "::", "G_FRAME_INDEX", ":", "return", "selectFrameIndexOrGep", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "selectGlobalValue", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "return", "selectConstant", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "materializeFP", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "selectTrunc", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_ZEXT", ":", "return", "selectZext", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "return", "selectAnyext", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "return", "selectCmp", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_UADDE", ":", "return", "selectUadde", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "return", "selectUnmergeValues", "(", "I", ",", "MRI", ",", "MF", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_MERGE_VALUES", ":", "return", "selectMergeValues", "(", "I", ",", "MRI", ",", "MF", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectExtract", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectInsert", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_BRCOND", ":", "return", "selectCondBranch", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "return", "selectImplicitDefOrPHI", "(", "I", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"", "\" C++ instruction selection: \"" ]

[]

[ "<s>", "RISCVProcFamilyEnum", "getProcFamily", "(", ")", "const", "{", "return", "RISCVProcFamily", ";", "}", "</s>" ]

[ "Returns", "RISC-V", "processor", "family", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_max_noce_ifcvt_seq_cost", "(", "edge", "e", ")", "{", "bool", "predictable_p", "=", "predictable_edge_p", "(", "e", ")", ";", "enum", "compiler_param", "param", "=", "(", "predictable_p", "?", "PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST", ":", "PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST", ")", ";", "if", "(", "global_options_set", ".", "x_param_values", "[", "param", "]", ")", "return", "PARAM_VALUE", "(", "param", ")", ";", "else", "return", "BRANCH_COST", "(", "true", ",", "predictable_p", ")", "*", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MAX_NOCE_IFCVT_SEQ_COST", ".", "Like", "the", "default", "implementation", ",", "but", "returns", "a", "lower", "bound", "." ]

[ "i386", "2" ]

[]

[ "<s>", "InstructionCost", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Opd1Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueKind", "Opd2Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", "=", "TTI", "::", "OP_None", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", "=", "TTI", "::", "OP_None", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", "=", "ArrayRef", "<", "const", "Value", "*", ">", "(", ")", ",", "const", "Instruction", "*", "CxtI", "=", "nullptr", ")", "{", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "if", "(", "ISD", "==", "ISD", "::", "ADD", "&&", "CostKind", "==", "TTI", "::", "TCK_RecipThroughput", ")", "return", "SCEVCheapExpansionBudget", ".", "getValue", "(", ")", "+", "1", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "BPF", "ISD::ADD", "1" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createX86NaClRewritePass", "(", ")", ")", ";", "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", "X86", "X86", "X86" ]

[]

[ "<s>", "s390_label_align", "(", "LABEL", ")", "{", "\"%r0\"", ",", "\"%r1\"", ",", "\"%r2\"", ",", "\"%r3\"", ",", "\"%r4\"", ",", "\"%r5\"", ",", "\"%r6\"", ",", "\"%r7\"", ",", "\\", "\"%r8\"", ",", "\"%r9\"", ",", "\"%r10\"", ",", "\"%r11\"", ",", "\"%r12\"", ",", "\"%r13\"", ",", "\"%r14\"", ",", "\"%r15\"", ",", "\\", "\"%f0\"", ",", "\"%f2\"", ",", "\"%f4\"", ",", "\"%f6\"", ",", "\"%f1\"", ",", "\"%f3\"", ",", "\"%f5\"", ",", "\"%f7\"", ",", "\\", "\"%f8\"", ",", "\"%f10\"", ",", "\"%f12\"", ",", "\"%f14\"", ",", "\"%f9\"", ",", "\"%f11\"", ",", "\"%f13\"", ",", "\"%f15\"", ",", "\\", "\"%ap\"", ",", "\"%cc\"", ",", "\"%fp\"", ",", "\"%rp\"", ",", "\"%a0\"", ",", "\"%a1\"", "\\", "}", "do", "{", "\\", "char", "buf", "[", "32", "]", ";", "\\", "fputs", "(", "integer_asm_op", "(", "UNITS_PER_LONG", ",", "TRUE", ")", ",", "(", "FILE", ")", ")", ";", "\\", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "(", "VALUE", ")", ")", ";", "\\", "assemble_name", "(", "(", "FILE", ")", ",", "buf", ")", ";", "\\", "fputc", "(", "'\\n'", ",", "(", "FILE", ")", ")", ";", "\\", "}", "</s>" ]

[ "Return", "the", "alignment", "for", "LABEL", ".", "We", "default", "to", "the", "-falign-labels", "value", "except", "for", "the", "literal", "pool", "base", "label", "." ]

[ "s390", "\"%r0\"", "\"%r1\"", "\"%r2\"", "\"%r3\"", "\"%r4\"", "\"%r5\"", "\"%r6\"", "\"%r7\"", "\"%r8\"", "\"%r9\"", "\"%r10\"", "\"%r11\"", "\"%r12\"", "\"%r13\"", "\"%r14\"", "\"%r15\"", "\"%f0\"", "\"%f2\"", "\"%f4\"", "\"%f6\"", "\"%f1\"", "\"%f3\"", "\"%f5\"", "\"%f7\"", "\"%f8\"", "\"%f10\"", "\"%f12\"", "\"%f14\"", "\"%f9\"", "\"%f11\"", "\"%f13\"", "\"%f15\"", "\"%ap\"", "\"%cc\"", "\"%fp\"", "\"%rp\"", "\"%a0\"", "\"%a1\"", "32", "\"L\"" ]

[]

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

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

[ "Hexagon", "\"Hexagon optimize vextract\"" ]

[]

[ "<s>", "static", "reg_class_t", "loongarch_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "reg_class_subset_p", "(", "FP_REGS", ",", "rclass", ")", "&&", "loongarch_mode_ok_for_mov_fmt_p", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "FP_REGS", ";", "if", "(", "reg_class_subset_p", "(", "GR_REGS", ",", "rclass", ")", ")", "rclass", "=", "GR_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

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

[ "loongarch" ]

[]

[ "<s>", "int", "visium_expand_block_set", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "bytes_rtx", "=", "operands", "[", "1", "]", ";", "rtx", "value_rtx", "=", "operands", "[", "2", "]", ";", "rtx", "align_rtx", "=", "operands", "[", "3", "]", ";", "const", "int", "align", "=", "INTVAL", "(", "align_rtx", ")", ";", "rtx", "dst_reg", ";", "tree", "dst_expr", ";", "if", "(", "!", "CONST_INT_P", "(", "bytes_rtx", ")", "||", "INTVAL", "(", "bytes_rtx", ")", "<=", "0", ")", "return", "0", ";", "dst_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "if", "(", "align", ">=", "4", ")", "expand_block_set_4", "(", "dst", ",", "dst_reg", ",", "value_rtx", ",", "bytes_rtx", ")", ";", "else", "if", "(", "align", ">=", "2", ")", "expand_block_set_2", "(", "dst", ",", "dst_reg", ",", "value_rtx", ",", "bytes_rtx", ")", ";", "else", "expand_block_set_1", "(", "dst_reg", ",", "value_rtx", ",", "bytes_rtx", ")", ";", "dst_expr", "=", "MEM_EXPR", "(", "dst", ")", ";", "if", "(", "dst_expr", ")", "mark_addressable", "(", "dst_expr", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Expand", "string/block", "set", "operations", ".", "operands", "[", "0", "]", "is", "the", "pointer", "to", "the", "destination", ".", "operands", "[", "1", "]", "is", "the", "number", "of", "bytes", "to", "set", ".", "operands", "[", "2", "]", "is", "the", "source", "value", ".", "operands", "[", "3", "]", "is", "the", "alignment", ".", "Return", "1", "upon", "success", ",", "0", "otherwise", "." ]

[ "visium", "0", "1", "2", "3", "0", "0", "0", "4", "2", "1" ]

[]

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

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

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

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PostRAMachineSinkingID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "const", "NVPTXSubtarget", "&", "ST", "=", "*", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", "ST", ".", "getSmVersion", "(", ")", ")", ")", ";", "if", "(", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "CUDA", ")", "{", "addPass", "(", "createGlobalOffsetPass", "(", ")", ")", ";", "addPass", "(", "createLocalAccessorToSharedMemoryPass", "(", ")", ")", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addAddressSpaceInferencePasses", "(", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addEarlyCSEOrGVNPass", "(", ")", ";", "if", "(", "!", "DisableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "tilepro_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "return", "true", ";", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "tilepro" ]

[]

[ "<s>", "int", "uns_arith_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "SMALL_INT_UNSIGNED", "(", "op", ")", ")", "return", "1", ";", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "truth", "value", "of", "whether", "OP", "can", "be", "used", "as", "an", "operands", "where", "a", "register", "or", "16", "bit", "unsigned", "integer", "is", "needed", "." ]

[ "mt", "1" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "pa_output_dbra", "(", "rtx", "*", "operands", ",", "rtx_insn", "*", "insn", ",", "int", "which_alternative", ")", "{", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "branch_to_delay_slot_p", "(", "insn", ")", ")", "{", "if", "(", "which_alternative", "==", "0", ")", "return", "\"ldo %1(%0),%0\"", ";", "else", "if", "(", "which_alternative", "==", "1", ")", "{", "output_asm_insn", "(", "\"{fstws|fstw} %0,-16(%%r30)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldw -16(%%r30),%4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldo %1(%4),%4\\n\\tstw %4,-16(%%r30)\"", ",", "operands", ")", ";", "return", "\"{fldws|fldw} -16(%%r30),%0\"", ";", "}", "else", "{", "output_asm_insn", "(", "\"ldw %0,%4\"", ",", "operands", ")", ";", "return", "\"ldo %1(%4),%4\\n\\tstw %4,%0\"", ";", "}", "}", "if", "(", "which_alternative", "==", "0", ")", "{", "int", "nullify", "=", "INSN_ANNULLED_BRANCH_P", "(", "insn", ")", ";", "int", "xdelay", ";", "if", "(", "length", "==", "8", "&&", "dbr_sequence_length", "(", ")", "==", "0", ")", "nullify", "=", "1", ";", "if", "(", "!", "nullify", "&&", "length", "==", "4", "&&", "dbr_sequence_length", "(", ")", "==", "0", ")", "nullify", "=", "forward_branch_p", "(", "insn", ")", ";", "switch", "(", "length", ")", "{", "case", "4", ":", "if", "(", "nullify", ")", "{", "if", "(", "branch_needs_nop_p", "(", "insn", ")", ")", "return", "\"addib,%C2,n %1,%0,%3%#\"", ";", "else", "return", "\"addib,%C2,n %1,%0,%3\"", ";", "}", "else", "return", "\"addib,%C2 %1,%0,%3\"", ";", "case", "8", ":", "if", "(", "dbr_sequence_length", "(", ")", "!=", "0", "&&", "!", "forward_branch_p", "(", "insn", ")", "&&", "nullify", ")", "return", "\"addib,%N2,n %1,%0,.+12\\n\\tb %3\"", ";", "else", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", "&&", "!", "forward_branch_p", "(", "insn", ")", "&&", "INSN_ADDRESSES_SET_P", "(", ")", "&&", "VAL_14_BITS_P", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "JUMP_LABEL", "(", "insn", ")", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "8", ")", ")", "return", "\"addib,%C2 %1,%0,%3%#\"", ";", "if", "(", "nullify", ")", "return", "\"addi,%N2 %1,%0,%0\\n\\tb,n %3\"", ";", "else", "return", "\"addi,%N2 %1,%0,%0\\n\\tb %3\"", ";", "default", ":", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", "||", "(", "nullify", "&&", "forward_branch_p", "(", "insn", ")", ")", ")", "{", "nullify", "=", "1", ";", "xdelay", "=", "0", ";", "operands", "[", "4", "]", "=", "GEN_INT", "(", "length", ")", ";", "}", "else", "{", "xdelay", "=", "1", ";", "operands", "[", "4", "]", "=", "GEN_INT", "(", "length", "+", "4", ")", ";", "}", "if", "(", "nullify", ")", "output_asm_insn", "(", "\"addib,%N2,n %1,%0,.+%4\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"addib,%N2 %1,%0,.+%4\"", ",", "operands", ")", ";", "return", "pa_output_lbranch", "(", "operands", "[", "3", "]", ",", "insn", ",", "xdelay", ")", ";", "}", "}", "else", "if", "(", "which_alternative", "==", "1", ")", "{", "output_asm_insn", "(", "\"{fstws|fstw} %0,-16(%%r30)\\n\\tldw -16(%%r30),%4\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldo %1(%4),%4\\n\\tstw %4,-16(%%r30)\"", ",", "operands", ")", ";", "if", "(", "length", "==", "24", ")", "return", "\"{comb|cmpb},%S2 %%r0,%4,%3\\n\\t{fldws|fldw} -16(%%r30),%0\"", ";", "else", "if", "(", "length", "==", "28", ")", "return", "\"{comclr|cmpclr},%B2 %%r0,%4,%%r0\\n\\tb %3\\n\\t{fldws|fldw} -16(%%r30),%0\"", ";", "else", "{", "operands", "[", "5", "]", "=", "GEN_INT", "(", "length", "-", "16", ")", ";", "output_asm_insn", "(", "\"{comb|cmpb},%B2 %%r0,%4,.+%5\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"{fldws|fldw} -16(%%r30),%0\"", ",", "operands", ")", ";", "return", "pa_output_lbranch", "(", "operands", "[", "3", "]", ",", "insn", ",", "0", ")", ";", "}", "}", "else", "{", "output_asm_insn", "(", "\"ldw %0,%4\"", ",", "operands", ")", ";", "if", "(", "length", "==", "12", ")", "return", "\"addib,%C2 %1,%4,%3\\n\\tstw %4,%0\"", ";", "else", "if", "(", "length", "==", "16", ")", "return", "\"addi,%N2 %1,%4,%4\\n\\tb %3\\n\\tstw %4,%0\"", ";", "else", "{", "operands", "[", "5", "]", "=", "GEN_INT", "(", "length", "-", "4", ")", ";", "output_asm_insn", "(", "\"addib,%N2 %1,%4,.+%5\\n\\tstw %4,%0\"", ",", "operands", ")", ";", "return", "pa_output_lbranch", "(", "operands", "[", "3", "]", ",", "insn", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "output", "template", "for", "emitting", "a", "dbra", "type", "insn", ".", "Note", "it", "may", "perform", "some", "output", "operations", "on", "its", "own", "before", "returning", "the", "final", "output", "string", "." ]

[ "pa", "0", "\"ldo %1(%0),%0\"", "1", "\"{fstws|fstw} %0,-16(%%r30)\"", "\"ldw -16(%%r30),%4\"", "\"ldo %1(%4),%4\\n\\tstw %4,-16(%%r30)\"", "\"{fldws|fldw} -16(%%r30),%0\"", "\"ldw %0,%4\"", "\"ldo %1(%4),%4\\n\\tstw %4,%0\"", "0", "8", "0", "1", "4", "0", "4", "\"addib,%C2,n %1,%0,%3%#\"", "\"addib,%C2,n %1,%0,%3\"", "\"addib,%C2 %1,%0,%3\"", "8", "0", "\"addib,%N2,n %1,%0,.+12\\n\\tb %3\"", "0", "8", "\"addib,%C2 %1,%0,%3%#\"", "\"addi,%N2 %1,%0,%0\\n\\tb,n %3\"", "\"addi,%N2 %1,%0,%0\\n\\tb %3\"", "0", "1", "0", "4", "1", "4", "4", "\"addib,%N2,n %1,%0,.+%4\"", "\"addib,%N2 %1,%0,.+%4\"", "3", "1", "\"{fstws|fstw} %0,-16(%%r30)\\n\\tldw -16(%%r30),%4\"", "\"ldo %1(%4),%4\\n\\tstw %4,-16(%%r30)\"", "24", "\"{comb|cmpb},%S2 %%r0,%4,%3\\n\\t{fldws|fldw} -16(%%r30),%0\"", "28", "\"{comclr|cmpclr},%B2 %%r0,%4,%%r0\\n\\tb %3\\n\\t{fldws|fldw} -16(%%r30),%0\"", "5", "16", "\"{comb|cmpb},%B2 %%r0,%4,.+%5\"", "\"{fldws|fldw} -16(%%r30),%0\"", "3", "0", "\"ldw %0,%4\"", "12", "\"addib,%C2 %1,%4,%3\\n\\tstw %4,%0\"", "16", "\"addi,%N2 %1,%4,%4\\n\\tb %3\\n\\tstw %4,%0\"", "5", "4", "\"addib,%N2 %1,%4,.+%5\\n\\tstw %4,%0\"", "3", "0" ]

[]

[ "<s>", "uint32_t", "ARMMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "ARMSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "return", "::", "getBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "ARM", "::", "fixup_t2_branch", ",", "Fixups", ")", ";", "return", "::", "getBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "ARM", "::", "fixup_arm_branch", ",", "Fixups", ")", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::fixup_t2_branch", "ARM::fixup_arm_branch" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "AMDGPU", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "Mov", ",", "AMDGPU", "::", "OpName", "::", "dst_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "write", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "AMDGPU::R600_AddrRegClass", "1", "AMDGPU::R600_Addr_YRegClass", "2", "AMDGPU::R600_Addr_ZRegClass", "3", "AMDGPU::R600_Addr_WRegClass", "AMDGPU::MOVA_INT_eg", "AMDGPU::AR_X", "AMDGPU::OpName", "0", "AMDGPU::MOV", "AMDGPU::AR_X", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "void", "DiagnosticInfoUnsupported", "::", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "{", "DP", "<<", "\"unsupported \"", "<<", "getDescription", "(", ")", "<<", "\" in \"", "<<", "Fn", ".", "getName", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"unsupported \"", "\" in \"" ]

[]

[ "<s>", "void", "s390_asm_output_function_label", "(", "FILE", "*", "asm_out_file", ",", "const", "char", "*", "fname", ",", "tree", "decl", ")", "{", "int", "hw_before", ",", "hw_after", ";", "s390_function_num_hotpatch_hw", "(", "decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_before", ">", "0", ")", "{", "unsigned", "int", "function_alignment", ";", "int", "i", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tnopr\\t%%r7\"", "\"\\t# pre-label NOPs for hotpatch (%d halfwords)\\n\"", ",", "hw_before", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "hw_before", ";", "i", "++", ")", "fputs", "(", "\"\\tnopr\\t%r7\\n\"", ",", "asm_out_file", ")", ";", "function_alignment", "=", "MAX", "(", "8", ",", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "!", "DECL_USER_ALIGN", "(", "decl", ")", ")", "function_alignment", "=", "MAX", "(", "function_alignment", ",", "(", "unsigned", "int", ")", "align_functions", ")", ";", "fputs", "(", "\"\\t# alignment for hotpatch\\n\"", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "floor_log2", "(", "function_alignment", ")", ")", ";", "}", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "fname", ")", ";", "if", "(", "hw_after", ">", "0", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t# post-label NOPs for hotpatch (%d halfwords)\\n\"", ",", "hw_after", ")", ";", "}", "</s>" ]

[ "Write", "the", "extra", "assembler", "code", "needed", "to", "declare", "a", "function", "properly", "." ]

[ "s390", "0", "\"\\tnopr\\t%%r7\"", "\"\\t# pre-label NOPs for hotpatch (%d halfwords)\\n\"", "1", "\"\\tnopr\\t%r7\\n\"", "8", "\"\\t# alignment for hotpatch\\n\"", "0", "\"\\t# post-label NOPs for hotpatch (%d halfwords)\\n\"" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "LiveRegs", ".", "init", "(", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "bool", "function_checker", "::", "require_immediate_one_of", "(", "unsigned", "int", "rel_argno", ",", "HOST_WIDE_INT", "value0", ",", "HOST_WIDE_INT", "value1", ",", "HOST_WIDE_INT", "value2", ",", "HOST_WIDE_INT", "value3", ")", "{", "unsigned", "int", "argno", "=", "m_base_arg", "+", "rel_argno", ";", "if", "(", "!", "argument_exists_p", "(", "argno", ")", ")", "return", "true", ";", "HOST_WIDE_INT", "actual", ";", "if", "(", "!", "require_immediate", "(", "argno", ",", "actual", ")", ")", "return", "false", ";", "if", "(", "actual", "!=", "value0", "&&", "actual", "!=", "value1", "&&", "actual", "!=", "value2", "&&", "actual", "!=", "value3", ")", "{", "report_not_one_of", "(", "location", ",", "fndecl", ",", "argno", ",", "actual", ",", "value0", ",", "value1", ",", "value2", ",", "value3", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "that", "argument", "REL_ARGNO", "is", "an", "integer", "constant", "expression", "that", "has", "one", "of", "the", "given", "values", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "TVMControlFlowPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"runnning TVMControlFlowPrepare on \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "std", "::", "vector", "<", "BasicBlock", "*", ">", "OriginalBBs", ";", "llvm", "::", "transform", "(", "F", ",", "std", "::", "back_inserter", "(", "OriginalBBs", ")", ",", "[", "]", "(", "BasicBlock", "&", "BB", ")", "{", "return", "&", "BB", ";", "}", ")", ";", "for", "(", "auto", "*", "BB", ":", "OriginalBBs", ")", "{", "if", "(", "pred_size", "(", "BB", ")", ">", "1", ")", "{", "insertCleanupBBs", "(", "BB", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"runnning TVMControlFlowPrepare on \"", "\"\\n\"", "1" ]

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "static", "bool", "frv_pack_insn_p", "(", "rtx", "insn", ")", "{", "if", "(", "frv_packet", ".", "num_insns", "==", "frv_packet", ".", "issue_rate", ")", "return", "false", ";", "if", "(", "frv_packet", ".", "num_insns", ">", "0", "&&", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_MODE", "(", "insn", ")", "==", "TImode", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "COND_EXEC", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SETLO", ")", "if", "(", "frv_registers_conflict_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "return", "state_transition", "(", "frv_packet", ".", "dfa_state", ",", "insn", ")", "<", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "can", "be", "added", "to", "the", "current", "packet", ".", "Update", "the", "DFA", "state", "on", "success", "." ]

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

[]

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "ICA", ".", "getID", "(", ")", "==", "Intrinsic", "::", "fabs", ")", "return", "0", ";", "if", "(", "!", "intrinsicHasPackedVectorBenefit", "(", "ICA", ".", "getID", "(", ")", ")", ")", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "Type", "*", "RetTy", "=", "ICA", ".", "getReturnType", "(", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "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", "(", "CostKind", ")", ";", "if", "(", "(", "ST", "->", "has16BitInsts", "(", ")", "&&", "SLT", "==", "MVT", "::", "f16", ")", "||", "(", "ST", "->", "hasPackedFP32Ops", "(", ")", "&&", "SLT", "==", "MVT", "::", "f32", ")", ")", "NElts", "=", "(", "NElts", "+", "1", ")", "/", "2", ";", "unsigned", "InstRate", "=", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "fma", ":", "InstRate", "=", "ST", "->", "hasFastFMAF32", "(", ")", "?", "getHalfRateInstrCost", "(", "CostKind", ")", ":", "getQuarterRateInstrCost", "(", "CostKind", ")", ";", "break", ";", "case", "Intrinsic", "::", "uadd_sat", ":", "case", "Intrinsic", "::", "usub_sat", ":", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "ssub_sat", ":", "static", "const", "auto", "ValidSatTys", "=", "{", "MVT", "::", "v2i16", ",", "MVT", "::", "v4i16", "}", ";", "if", "(", "any_of", "(", "ValidSatTys", ",", "[", "&", "LT", "]", "(", "MVT", "M", ")", "{", "return", "M", "==", "LT", ".", "second", ";", "}", ")", ")", "NElts", "=", "1", ";", "break", ";", "}", "return", "LT", ".", "first", "*", "NElts", "*", "InstRate", ";", "}", "</s>" ]

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

[ "AMDGPU", "Intrinsic::fabs", "0", "1", "MVT::SimpleValueType", "MVT::f64", "MVT::f16", "MVT::f32", "1", "2", "Intrinsic::fma", "Intrinsic::uadd_sat", "Intrinsic::usub_sat", "Intrinsic::sadd_sat", "Intrinsic::ssub_sat", "MVT::v2i16", "MVT::v4i16", "1" ]

[]

[ "<s>", "unsigned", "int", "UPTInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "unsigned", "NumInserted", "=", "0", ";", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "UPT", "::", "Bcc", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "NumInserted", "++", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", "||", "FBB", ")", "{", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DL", ",", "get", "(", "UPT", "::", "JMP", ")", ")", ".", "addMBB", "(", "Cond", ".", "empty", "(", ")", "?", "TBB", ":", "FBB", ")", ";", "NumInserted", "++", ";", "}", "return", "NumInserted", ";", "}", "</s>" ]

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

[ "UPT", "UPT", "0", "UPT::Bcc", "0", "UPT::JMP" ]

[]

[ "<s>", "void", "AZPRFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\">> AZPRFrameLowering::emitEpilogue <<\\n\"", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AZPRInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "AZPRInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "AZPR", "::", "ADDUI", ")", ",", "AZPR", "::", "r30", ")", ".", "addReg", "(", "AZPR", "::", "r30", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "</s>" ]

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

[ "AZPR", "AZPR", "\">> AZPRFrameLowering::emitEpilogue <<\\n\"", "AZPR", "AZPR", "AZPR::ADDUI", "AZPR::r30", "AZPR::r30" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "{", "assert", "(", "SrcAS", "!=", "DestAS", "&&", "\"Expected different address spaces!\"", ")", ";", "if", "(", "getPointerSize", "(", "SrcAS", ")", "!=", "getPointerSize", "(", "DestAS", ")", ")", "return", "false", ";", "return", "SrcAS", "<", "256", "&&", "DestAS", "<", "256", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

[ "X86", "X86", "\"Expected different address spaces!\"", "256", "256" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "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", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isNarrowingProfitable", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "!", "(", "VT1", "==", "MVT", "::", "i24", "&&", "VT2", "==", "MVT", "::", "i16", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "narrow", "operations", "of", "type", "SrcVT", "to", "DestVT", "." ]

[ "Z80old", "Z80old", "MVT::i24", "MVT::i16" ]

[]

[ "<s>", "static", "void", "sh_print_operand_address", "(", "FILE", "*", "stream", ",", "machine_mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "fprintf", "(", "stream", ",", "\"@%s\"", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "\"@(%d,%s)\"", ",", "(", "int", ")", "INTVAL", "(", "index", ")", ",", "reg_names", "[", "true_regnum", "(", "base", ")", "]", ")", ";", "break", ";", "case", "REG", ":", "case", "SUBREG", ":", "{", "int", "base_num", "=", "true_regnum", "(", "base", ")", ";", "int", "index_num", "=", "true_regnum", "(", "index", ")", ";", "if", "(", "base_num", "==", "0", "&&", "index_num", "!=", "0", ")", "std", "::", "swap", "(", "base_num", ",", "index_num", ")", ";", "fprintf", "(", "stream", ",", "\"@(%s,%s)\"", ",", "reg_names", "[", "index_num", "]", ",", "reg_names", "[", "base_num", "]", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "stream", ",", "\"@-%s\"", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "stream", ",", "\"@%s+\"", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "default", ":", "x", "=", "mark_constant_pool_use", "(", "x", ")", ";", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "sh", "\"@%s\"", "0", "1", "\"@(%d,%s)\"", "0", "0", "\"@(%s,%s)\"", "\"@-%s\"", "0", "\"@%s+\"", "0" ]

[]

[ "<s>", "unsigned", "PPCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_invalid_within_doloop", "(", "rtx", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "\"Function call in the loop.\"", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", ")", ")", "return", "\"Computed branch in the loop.\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "NULL", "if", "INSN", "insn", "is", "valid", "within", "a", "low-overhead", "loop", ".", "Otherwise", "return", "why", "doloop", "can", "not", "be", "applied", ".", "PowerPC", "uses", "the", "COUNT", "register", "for", "branch", "on", "table", "instructions", "." ]

[ "rs6000", "\"Function call in the loop.\"", "\"Computed branch in the loop.\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "ARM", "::", "GPRRegClassID", ":", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "case", "ARM", "::", "GPRPairRegClassID", ":", "return", "Super", ";", "case", "ARM", "::", "QPRRegClassID", ":", "case", "ARM", "::", "QQPRRegClassID", ":", "case", "ARM", "::", "QQQQPRRegClassID", ":", "if", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "hasNEON", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegClassID", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "ARM::GPRPairRegClassID", "ARM::QPRRegClassID", "ARM::QQPRRegClassID", "ARM::QQQQPRRegClassID", "ARM" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "HexagonInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", "&", "~", "HexagonII", "::", "MO_Bitmasks", ",", "TF", "&", "HexagonII", "::", "MO_Bitmasks", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "Hexagon", "Hexagon", "HexagonII::MO_Bitmasks", "HexagonII::MO_Bitmasks" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_asm_init_sections", "(", "void", ")", "{", "read_only_data_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_read_only_section_name", ")", ";", "private_data_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "rs6000_xcoff_output_readwrite_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "tls_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_tls_data_section_name", ")", ";", "tls_private_data_section", "=", "get_unnamed_section", "(", "SECTION_TLS", ",", "rs6000_xcoff_output_tls_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "read_only_private_data_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_readonly_section_asm_op", ",", "&", "xcoff_private_data_section_name", ")", ";", "toc_section", "=", "get_unnamed_section", "(", "0", ",", "rs6000_xcoff_output_toc_section_asm_op", ",", "NULL", ")", ";", "readonly_data_section", "=", "read_only_data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INIT_SECTIONS", "." ]

[ "powerpcspe", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "msp430_print_operand_addr", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PLUS", ":", "msp430_print_operand_raw", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "return", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"@\"", ")", ";", "break", ";", "case", "CONST", ":", "case", "CONST_INT", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "fprintf", "(", "file", ",", "\"&\"", ")", ";", "break", ";", "default", ":", "break", ";", "}", "msp430_print_operand_raw", "(", "file", ",", "addr", ")", ";", "}", "</s>" ]

[ "Output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", "." ]

[ "msp430", "1", "0", "\"(%s)\"", "0", "\"@\"", "\"&\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "Thumb1InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "MachineBasicBlock", "*", "LM32TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "false", "&&", "\"Unexpected instr type to insert\"", ")", ";", "case", "LM32", "::", "SelectCC_Opc", ":", "return", "EmitCustomSelect", "(", "MI", ",", "MBB", ")", ";", "}", "}", "</s>" ]

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

[ "LM32", "LM32", "\"Unexpected instr type to insert\"", "LM32::SelectCC_Opc" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "AMDGPUASI", "=", "TM", ".", "getAMDGPUAS", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "KudeyarFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ">", "1", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "POPA", ")", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "}", "}", "else", "{", "unsigned", "Reg", "=", "CSI", "[", "0", "]", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "POP_R", ")", ",", "Reg", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Kudeyar", "::", "POP_R", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "1", "Kudeyar::POPA", "0", "1", "0", "Kudeyar::POP_R", "0", "Kudeyar::POP_R" ]

[]

[ "<s>", "void", "avr_output_addr_vec_elt", "(", "FILE", "*", "stream", ",", "int", "value", ")", "{", "if", "(", "AVR_HAVE_JMP_CALL", ")", "fprintf", "(", "stream", ",", "\"\\t.word gs(.L%d)\\n\"", ",", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\trjmp .L%d\\n\"", ",", "value", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "`", "ASM_OUTPUT_ADDR_VEC_ELT", "'", "." ]

[ "avr", "\"\\t.word gs(.L%d)\\n\"", "\"\\trjmp .L%d\\n\"" ]

[]

[ "<s>", "static", "bool", "msp430_check_index_not_high_mem", "(", "rtx", "op", ")", "{", "if", "(", "CONST_INT_P", "(", "op", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "op", ")", ",", "HOST_WIDE_INT_M1U", "<<", "15", ",", "(", "1", "<<", "15", ")", "-", "1", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "We", "can", "only", "allow", "signed", "15-bit", "indexes", "i.e", ".", "+/-32K", "." ]

[ "msp430", "15", "1", "15", "1" ]

[]

[ "<s>", "static", "tree", "sparc_gimplify_va_arg", "(", "tree", "valist", ",", "tree", "type", ",", "tree", "*", "pre_p", ",", "tree", "*", "post_p", ")", "{", "HOST_WIDE_INT", "size", ",", "rsize", ",", "align", ";", "tree", "addr", ",", "incr", ";", "bool", "indirect", ";", "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "if", "(", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ")", "{", "indirect", "=", "true", ";", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "align", "=", "0", ";", "}", "else", "{", "indirect", "=", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "-", "UNITS_PER_WORD", ";", "align", "=", "0", ";", "if", "(", "TARGET_ARCH64", ")", "{", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">=", "2", "*", "(", "unsigned", ")", "BITS_PER_WORD", ")", "align", "=", "2", "*", "UNITS_PER_WORD", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "size", "==", "0", ")", "size", "=", "rsize", "=", "UNITS_PER_WORD", ";", "else", "size", "=", "rsize", ";", "}", "}", "}", "incr", "=", "valist", ";", "if", "(", "align", ")", "{", "incr", "=", "fold", "(", "build2", "(", "PLUS_EXPR", ",", "ptr_type_node", ",", "incr", ",", "ssize_int", "(", "align", "-", "1", ")", ")", ")", ";", "incr", "=", "fold", "(", "build2", "(", "BIT_AND_EXPR", ",", "ptr_type_node", ",", "incr", ",", "ssize_int", "(", "-", "align", ")", ")", ")", ";", "}", "gimplify_expr", "(", "&", "incr", ",", "pre_p", ",", "post_p", ",", "is_gimple_val", ",", "fb_rvalue", ")", ";", "addr", "=", "incr", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "size", "<", "rsize", ")", "addr", "=", "fold", "(", "build2", "(", "PLUS_EXPR", ",", "ptr_type_node", ",", "incr", ",", "ssize_int", "(", "rsize", "-", "size", ")", ")", ")", ";", "if", "(", "indirect", ")", "{", "addr", "=", "fold_convert", "(", "build_pointer_type", "(", "ptrtype", ")", ",", "addr", ")", ";", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "else", "if", "(", "align", "==", "0", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "BITS_PER_WORD", ")", "{", "tree", "tmp", "=", "create_tmp_var", "(", "type", ",", "\"va_arg_tmp\"", ")", ";", "tree", "dest_addr", "=", "build_fold_addr_expr", "(", "tmp", ")", ";", "tree", "copy", "=", "build_function_call_expr", "(", "implicit_built_in_decls", "[", "BUILT_IN_MEMCPY", "]", ",", "tree_cons", "(", "NULL_TREE", ",", "dest_addr", ",", "tree_cons", "(", "NULL_TREE", ",", "addr", ",", "tree_cons", "(", "NULL_TREE", ",", "size_int", "(", "rsize", ")", ",", "NULL_TREE", ")", ")", ")", ")", ";", "gimplify_and_add", "(", "copy", ",", "pre_p", ")", ";", "addr", "=", "dest_addr", ";", "}", "else", "addr", "=", "fold_convert", "(", "ptrtype", ",", "addr", ")", ";", "incr", "=", "fold", "(", "build2", "(", "PLUS_EXPR", ",", "ptr_type_node", ",", "incr", ",", "ssize_int", "(", "rsize", ")", ")", ")", ";", "incr", "=", "build2", "(", "MODIFY_EXPR", ",", "ptr_type_node", ",", "valist", ",", "incr", ")", ";", "gimplify_and_add", "(", "incr", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "`", "va_arg", "'", "for", "stdarg", "." ]

[ "sparc", "0", "1", "0", "2", "2", "0", "1", "0", "\"va_arg_tmp\"" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAllocaToVector", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", "||", "DisablePromoteAllocaToVector", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "SmallVector", "<", "AllocaInst", "*", ",", "16", ">", "Allocas", ";", "for", "(", "Instruction", "&", "I", ":", "EntryBB", ")", "{", "if", "(", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "Allocas", ".", "push_back", "(", "AI", ")", ";", "}", "for", "(", "AllocaInst", "*", "AI", ":", "Allocas", ")", "{", "if", "(", "handleAlloca", "(", "*", "AI", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARMInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tRestore", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FLDD", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", "&&", "\"Unknown regclass!\"", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FLDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegisterClass", "ARM", "ARM", "ARM::LDR", "0", "0", "ARM::tGPRRegisterClass", "ARM", "ARM", "ARM::tRestore", "0", "ARM::DPRRegisterClass", "ARM::FLDD", "0", "ARM::SPRRegisterClass", "\"Unknown regclass!\"", "ARM::FLDS", "0" ]

[]

[ "<s>", "bool", "A64Imms", "::", "isFPImm", "(", "const", "APFloat", "&", "Val", ",", "uint32_t", "&", "Imm8Bits", ")", "{", "const", "fltSemantics", "&", "Sem", "=", "Val", ".", "getSemantics", "(", ")", ";", "unsigned", "FracBits", "=", "APFloat", "::", "semanticsPrecision", "(", "Sem", ")", "-", "1", ";", "uint32_t", "ExpMask", ";", "switch", "(", "FracBits", ")", "{", "case", "10", ":", "ExpMask", "=", "0x1f", ";", "break", ";", "case", "23", ":", "ExpMask", "=", "0xff", ";", "break", ";", "case", "52", ":", "ExpMask", "=", "0x7ff", ";", "break", ";", "case", "112", ":", "return", "false", ";", "default", ":", "llvm_unreachable", "(", "\"Only half, single and double precision supported\"", ")", ";", "}", "uint32_t", "ExpStart", "=", "FracBits", ";", "uint64_t", "FracMask", "=", "(", "1ULL", "<<", "FracBits", ")", "-", "1", ";", "uint32_t", "Sign", "=", "Val", ".", "isNegative", "(", ")", ";", "uint64_t", "Bits", "=", "Val", ".", "bitcastToAPInt", "(", ")", ".", "getLimitedValue", "(", ")", ";", "uint64_t", "Fraction", "=", "Bits", "&", "FracMask", ";", "int32_t", "Exponent", "=", "(", "(", "Bits", ">>", "ExpStart", ")", "&", "ExpMask", ")", ";", "Exponent", "-=", "ExpMask", ">>", "1", ";", "uint64_t", "A64FracStart", "=", "FracBits", "-", "4", ";", "uint64_t", "A64FracMask", "=", "0xf", ";", "if", "(", "Fraction", "&", "~", "(", "A64FracMask", "<<", "A64FracStart", ")", ")", "return", "false", ";", "if", "(", "Exponent", "<", "-", "3", "||", "Exponent", ">", "4", ")", "return", "false", ";", "uint32_t", "PackedFraction", "=", "(", "Fraction", ">>", "A64FracStart", ")", "&", "A64FracMask", ";", "uint32_t", "PackedExp", "=", "(", "Exponent", "+", "7", ")", "&", "0x7", ";", "Imm8Bits", "=", "(", "Sign", "<<", "7", ")", "|", "(", "PackedExp", "<<", "4", ")", "|", "PackedFraction", ";", "return", "true", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "AArch64", "1", "10", "0x1f", "23", "0xff", "52", "0x7ff", "112", "\"Only half, single and double precision supported\"", "1ULL", "1", "1", "4", "0xf", "3", "4", "7", "0x7", "7", "4" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "getFnAttributes", "(", ")", ".", "hasAttribute", "(", "Attributes", "::", "NoImplicitFloat", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "&&", "Size", ">=", "16", ")", "{", "return", "MVT", "::", "v4i32", ";", "}", "else", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "&&", "Size", ">=", "8", ")", "{", "return", "MVT", "::", "v2i32", ";", "}", "}", "if", "(", "Size", ">=", "4", ")", "{", "return", "MVT", "::", "i32", ";", "}", "else", "if", "(", "Size", ">=", "2", ")", "{", "return", "MVT", "::", "i16", ";", "}", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "16", "16", "MVT::v4i32", "8", "8", "MVT::v2i32", "4", "MVT::i32", "2", "MVT::i16", "MVT::Other" ]

[]

[ "<s>", "int", "rs6000_trampoline_size", "(", "void", ")", "{", "int", "ret", "=", "0", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "12", ":", "24", ";", "break", ";", "case", "ABI_DARWIN", ":", "case", "ABI_V4", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "40", ":", "48", ";", "break", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Length", "in", "units", "of", "the", "trampoline", "for", "entering", "a", "nested", "function", "." ]

[ "rs6000", "0", "12", "24", "40", "48" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "{", "switch", "(", "ST", ".", "getGeneration", "(", ")", ")", "{", "default", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX9", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA9", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX10", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA10", ";", "break", ";", "}", "}", "if", "(", "isMAI", "(", "Opcode", ")", ")", "{", "int", "MFMAOp", "=", "AMDGPU", "::", "getMFMAEarlyClobberOp", "(", "Opcode", ")", ";", "if", "(", "MFMAOp", "!=", "-", "1", ")", "Opcode", "=", "MFMAOp", ";", "}", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "{", "uint16_t", "NMCOp", "=", "(", "uint16_t", ")", "-", "1", ";", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX90A", ")", ";", "if", "(", "NMCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "NMCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "SIEncodingFamily", "::", "GFX9", ")", ";", "if", "(", "NMCOp", "!=", "(", "uint16_t", ")", "-", "1", ")", "MCOp", "=", "NMCOp", ";", "}", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "if", "(", "isAsmOnlyOpcode", "(", "MCOp", ")", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "SIInstrFlags::SDWA", "SIEncodingFamily::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "AMDGPU", "SIEncodingFamily::SDWA10", "AMDGPU::getMFMAEarlyClobberOp", "1", "AMDGPU::getMCOpcode", "1", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX90A", "1", "AMDGPU::getMCOpcode", "SIEncodingFamily::GFX9", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "sparc_tls_got", "(", "void", ")", "{", "rtx", "temp", ";", "if", "(", "flag_pic", ")", "{", "current_function_uses_pic_offset_table", "=", "1", ";", "return", "pic_offset_table_rtx", ";", "}", "if", "(", "!", "global_offset_table", ")", "global_offset_table", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "temp", ",", "global_offset_table", ")", ";", "return", "temp", ";", "}", "</s>" ]

[ "Return", "the", "Global", "Offset", "Table", "to", "be", "used", "in", "TLS", "mode", "." ]

[ "sparc", "1", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "SUBSWrr", ":", "case", "AArch64", "::", "SUBSWrs", ":", "case", "AArch64", "::", "SUBSWrx", ":", "case", "AArch64", "::", "SUBSXrr", ":", "case", "AArch64", "::", "SUBSXrs", ":", "case", "AArch64", "::", "SUBSXrx", ":", "case", "AArch64", "::", "ADDSWrr", ":", "case", "AArch64", "::", "ADDSWrs", ":", "case", "AArch64", "::", "ADDSWrx", ":", "case", "AArch64", "::", "ADDSXrr", ":", "case", "AArch64", "::", "ADDSXrs", ":", "case", "AArch64", "::", "ADDSXrx", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "case", "AArch64", "::", "ADDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", ";", "return", "true", ";", "case", "AArch64", "::", "ANDSWri", ":", "case", "AArch64", "::", "ANDSXri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "AArch64_AM", "::", "decodeLogicalImmediate", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "ANDSWri", "?", "32", ":", "64", ")", "!=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreSched2", "(", ")", "{", "const", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "addPass", "(", "createHexagonCopyToCombine", "(", ")", ",", "false", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ",", "false", ")", ";", "addPass", "(", "createHexagonSplitConst32AndConst64", "(", "TM", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "MSP430Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "const", "MachineOperand", "*", "getNamedOperand", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpName", ")", "const", "{", "return", "getNamedOperand", "(", "const_cast", "<", "MachineInstr", "&", ">", "(", "MI", ")", ",", "OpName", ")", ";", "}", "</s>" ]

[ "Returns", "the", "operand", "named", "Op", "." ]

[ "R600" ]

[]

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

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

[ "GBZ80", "GB" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalT1ScaledAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "EVT", "VT", ")", "const", "{", "const", "int", "Scale", "=", "AM", ".", "Scale", ";", "if", "(", "Scale", "<", "0", ")", "return", "false", ";", "return", "(", "Scale", "==", "1", ")", "||", "(", "!", "AM", ".", "HasBaseReg", "&&", "Scale", "==", "2", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "addressing", "mode", "representing", "by", "AM", "is", "legal", "for", "the", "Thumb1", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM", "0", "1", "2" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableCExtOpt", ")", "addPass", "(", "createHexagonConstExtenders", "(", ")", ")", ";", "if", "(", "EnableExpandCondsets", ")", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "HexagonExpandCondsetsID", ")", ";", "if", "(", "!", "DisableStoreWidening", ")", "addPass", "(", "createHexagonStoreWidening", "(", ")", ")", ";", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonHardwareLoops", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", ")", "addPass", "(", "&", "MachinePipelinerID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "rs6000_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "bool", "testing_p", "=", "!", "target", ";", "if", "(", "TARGET_ALTIVEC", "&&", "testing_p", ")", "return", "true", ";", "if", "(", "(", "vmode", "==", "V2SFmode", "&&", "TARGET_PAIRED_FLOAT", ")", "||", "(", "(", "vmode", "==", "V2DFmode", "||", "vmode", "==", "V2DImode", ")", "&&", "VECTOR_MEM_VSX_P", "(", "vmode", ")", ")", ")", "{", "if", "(", "testing_p", ")", "{", "op0", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "op1", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "}", "if", "(", "rs6000_expand_vec_perm_const_1", "(", "target", ",", "op0", ",", "op1", ",", "sel", "[", "0", "]", ",", "sel", "[", "1", "]", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_ALTIVEC", ")", "{", "if", "(", "vmode", "!=", "V16QImode", ")", "return", "false", ";", "if", "(", "altivec_expand_vec_perm_const", "(", "target", ",", "op0", ",", "op1", ",", "sel", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "JVM" ]

[]

[ "<s>", "static", "inline", "int", "regno_or_subregno", "(", "rtx", "op", ")", "{", "if", "(", "REG_P", "(", "op", ")", ")", "return", "REGNO", "(", "op", ")", ";", "else", "if", "(", "SUBREG_P", "(", "op", ")", ")", "return", "subreg_regno", "(", "op", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "return", "the", "register", "number", "of", "a", "RTX", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "virtual", "SDNode", "*", "PostISelFolding", "(", "MachineSDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "N", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "R600" ]

[]

[ "<s>", "void", "emitTBSSSymbol", "(", "MCSection", "*", "Section", ",", "MCSymbol", "*", "Symbol", ",", "uint64_t", "Size", ",", "unsigned", "ByteAlignment", "=", "0", ")", "override", "{", "}", "</s>" ]

[ "Emit", "a", "thread", "local", "bss", "(", ".tbss", ")", "symbol", "." ]

[ "Patmos", "0" ]

[]