Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "M68kPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addISelPrepare", "(", ")", "{", "addPass", "(", "new", "CoalesceFeaturesAndStripAtomics", "(", "&", "getWebAssemblyTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addISelPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "in", "preparation", "for", "instruction", "selection", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "nios2_symbol_ref_in_small_data_p", "(", "rtx", "sym", ")", "{", "tree", "decl", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "sym", ")", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "TARGET_ARCH_R2", "&&", "(", "TARGET_BYPASS_CACHE", "||", "TARGET_BYPASS_CACHE_VOLATILE", ")", ")", "return", "false", ";", "switch", "(", "nios2_gpopt_option", ")", "{", "case", "gpopt_none", ":", "return", "false", ";", "case", "gpopt_local", ":", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "return", "nios2_small_section_name_p", "(", "DECL_SECTION_NAME", "(", "decl", ")", ")", ";", "return", "(", "SYMBOL_REF_SMALL_P", "(", "sym", ")", "&&", "!", "SYMBOL_REF_EXTERNAL_P", "(", "sym", ")", "&&", "!", "(", "decl", "&&", "DECL_WEAK", "(", "decl", ")", ")", "&&", "!", "(", "decl", "&&", "DECL_COMMON", "(", "decl", ")", "&&", "(", "DECL_INITIAL", "(", "decl", ")", "==", "NULL", "||", "(", "!", "in_lto_p", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "error_mark_node", ")", ")", ")", ")", ";", "case", "gpopt_global", ":", "return", "SYMBOL_REF_SMALL_P", "(", "sym", ")", ";", "case", "gpopt_data", ":", "return", "!", "SYMBOL_REF_FUNCTION_P", "(", "sym", ")", ";", "case", "gpopt_all", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "symbol", "is", "in", "small", "data", "section", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "static", "rtx", "strip_offset_and_salt", "(", "rtx", "addr", ",", "poly_int64", "*", "offset", ")", "{", "return", "strip_salt", "(", "strip_offset", "(", "addr", ",", "offset", ")", ")", ";", "}", "</s>" ]

[ "Like", "strip_offset", ",", "but", "also", "strip", "any", "UNSPEC_SALT_ADDR", "from", "the", "expression", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "char", "*", "arithmetic_instr", "(", "rtx", "op", ",", "int", "shift_first_arg", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "PLUS", ":", "return", "\"add\"", ";", "case", "MINUS", ":", "return", "shift_first_arg", "?", "\"rsb\"", ":", "\"sub\"", ";", "case", "IOR", ":", "return", "\"orr\"", ";", "case", "XOR", ":", "return", "\"eor\"", ";", "case", "AND", ":", "return", "\"and\"", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ROTATERT", ":", "return", "arm_shift_nmem", "(", "GET_CODE", "(", "op", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "appropriate", "ARM", "instruction", "for", "the", "operation", "code", ".", "The", "returned", "result", "should", "not", "be", "overwritten", ".", "OP", "is", "the", "rtx", "of", "the", "operation", ".", "SHIFT_FIRST_ARG", "is", "TRUE", "if", "the", "first", "argument", "of", "the", "operator", "was", "shifted", "." ]

[ "arm", "\"add\"", "\"rsb\"", "\"sub\"", "\"orr\"", "\"eor\"", "\"and\"" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "LiveRangeShrinkID", ")", ";", "addPass", "(", "createX86FixupSetCC", "(", ")", ")", ";", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "addPass", "(", "createX86AvoidStoreForwardingBlocks", "(", ")", ")", ";", "}", "addPass", "(", "createX86FlagsCopyLoweringPass", "(", ")", ")", ";", "addPass", "(", "createX86WinAllocaExpander", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDNode", "*", "GBZ80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "static", "int", "m68k_sched_first_cycle_multipass_dfa_lookahead", "(", "void", ")", "{", "return", "m68k_sched_issue_rate", "(", ")", "-", "1", ";", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "should", "scheduler", "lookahead", "to", "choose", "the", "best", "one", "." ]

[ "m68k", "1" ]

[]

[ "<s>", "bool", "AMDGPUDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DominatorTree", "&", "DT", "=", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "LoopInfo", "*", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "LI", "->", "getLoopsInPreorder", "(", ")", ")", "{", "assert", "(", "L", "->", "isLCSSAForm", "(", "DT", ")", ")", ";", "}", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "nds32_reg_base_load_store_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "mem_src", "=", "NULL_RTX", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "mem_src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "mem_src", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "mem_src", "!=", "NULL_RTX", ")", "{", "if", "(", "(", "GET_CODE", "(", "mem_src", ")", "==", "ZERO_EXTEND", ")", "||", "(", "GET_CODE", "(", "mem_src", ")", "==", "SIGN_EXTEND", ")", ")", "mem_src", "=", "XEXP", "(", "mem_src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "REG", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "is", "load/store", "with", "REG", "addressing", "mode", "and", "memory", "mode", "is", "SImode", "." ]

[ "nds32", "0", "0" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass2", "(", ")", "{", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "TM", "->", "getMCAsmInfo", "(", ")", ";", "addPass", "(", "createX86IndirectThunksPass", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "addPass", "(", "createX86AvoidTrailingCallPass", "(", ")", ")", ";", "if", "(", "!", "TT", ".", "isOSDarwin", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "DwarfCFI", ")", ")", "addPass", "(", "createCFIInstrInserter", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createX86LoadValueInjectionRetHardeningPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "static", "enum", "aarch64_parse_opt_result", "aarch64_parse_arch", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ",", "std", "::", "string", "*", "invalid_extension", ")", "{", "const", "char", "*", "ext", ";", "const", "struct", "processor", "*", "arch", ";", "size_t", "len", ";", "ext", "=", "strchr", "(", "to_parse", ",", "'+'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "to_parse", ";", "else", "len", "=", "strlen", "(", "to_parse", ")", ";", "if", "(", "len", "==", "0", ")", "return", "AARCH64_PARSE_MISSING_ARG", ";", "for", "(", "arch", "=", "all_architectures", ";", "arch", "->", "name", "!=", "NULL", ";", "arch", "++", ")", "{", "if", "(", "strlen", "(", "arch", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "arch", "->", "name", ",", "to_parse", ",", "len", ")", "==", "0", ")", "{", "unsigned", "long", "isa_temp", "=", "arch", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "enum", "aarch64_parse_opt_result", "ext_res", "=", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ",", "invalid_extension", ")", ";", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "return", "ext_res", ";", "}", "*", "res", "=", "arch", ";", "*", "isa_flags", "=", "isa_temp", ";", "return", "AARCH64_PARSE_OK", ";", "}", "}", "return", "AARCH64_PARSE_INVALID_ARG", ";", "}", "</s>" ]

[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "architecture", "struct", "that", "it", "selects", "into", "RES", "and", "the", "architectural", "features", "into", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]

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

[]

[ "<s>", "bool", "nds32_n9_last_load_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "last_def_reg", "=", "extract_nth_access_reg", "(", "producer", ",", "-", "1", ")", ";", "if", "(", "nds32_register_ports_config", "==", "REG_PORT_2R1W", ")", "{", "if", "(", "post_update_insn_p", "(", "producer", ")", ")", "return", "false", ";", "size_t", "i", ";", "size_t", "n_elems", "=", "parallel_elements", "(", "producer", ")", ";", "rtx", "base_reg", "=", "extract_base_reg", "(", "producer", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elems", ";", "++", "i", ")", "{", "rtx", "load_rtx", "=", "extract_nth_access_rtx", "(", "producer", ",", "i", ")", ";", "rtx", "list_element", "=", "SET_DEST", "(", "load_rtx", ")", ";", "if", "(", "rtx_equal_p", "(", "base_reg", ",", "list_element", ")", "&&", "i", "!=", "n_elems", "-", "1", ")", "{", "last_def_reg", "=", "base_reg", ";", "break", ";", "}", "}", "return", "n9_2r1w_consumed_by_ex_dep_p", "(", "consumer", ",", "last_def_reg", ")", ";", "}", "else", "return", "n9_3r2w_consumed_by_ex_dep_p", "(", "consumer", ",", "last_def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "LMW", "(", "N", ",", "N", ")", "to", "EX", "." ]

[ "nds32", "1", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "SIBCALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "PCREL_OFFSET", ")", ";", "OPCODE", "(", "IABS", ")", ";", "OPCODE", "(", "ICMP", ")", ";", "OPCODE", "(", "FCMP", ")", ";", "OPCODE", "(", "TM", ")", ";", "OPCODE", "(", "BR_CCMASK", ")", ";", "OPCODE", "(", "SELECT_CCMASK", ")", ";", "OPCODE", "(", "ADJDYNALLOC", ")", ";", "OPCODE", "(", "EXTRACT_ACCESS", ")", ";", "OPCODE", "(", "UMUL_LOHI64", ")", ";", "OPCODE", "(", "SDIVREM64", ")", ";", "OPCODE", "(", "UDIVREM32", ")", ";", "OPCODE", "(", "UDIVREM64", ")", ";", "OPCODE", "(", "MVC", ")", ";", "OPCODE", "(", "MVC_LOOP", ")", ";", "OPCODE", "(", "NC", ")", ";", "OPCODE", "(", "NC_LOOP", ")", ";", "OPCODE", "(", "OC", ")", ";", "OPCODE", "(", "OC_LOOP", ")", ";", "OPCODE", "(", "XC", ")", ";", "OPCODE", "(", "XC_LOOP", ")", ";", "OPCODE", "(", "CLC", ")", ";", "OPCODE", "(", "CLC_LOOP", ")", ";", "OPCODE", "(", "STRCMP", ")", ";", "OPCODE", "(", "STPCPY", ")", ";", "OPCODE", "(", "SEARCH_STRING", ")", ";", "OPCODE", "(", "IPM", ")", ";", "OPCODE", "(", "SERIALIZE", ")", ";", "OPCODE", "(", "ATOMIC_SWAPW", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_ADD", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_SUB", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_AND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_OR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_XOR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_NAND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MAX", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMAX", ")", ";", "OPCODE", "(", "ATOMIC_CMP_SWAPW", ")", ";", "OPCODE", "(", "PREFETCH", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "unsigned", "int", "insn_is_swappable_p", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "unsigned", "int", "*", "special", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "return", "0", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_load", ")", "{", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "*", "special", "=", "SH_NOSWAP_LD", ";", "return", "1", ";", "}", "else", "return", "0", ";", "}", "if", "(", "insn_entry", "[", "i", "]", ".", "is_store", ")", "{", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "!=", "UNSPEC", ")", "{", "*", "special", "=", "SH_NOSWAP_ST", ";", "return", "1", ";", "}", "else", "return", "0", ";", "}", "return", "rtx_is_swappable_p", "(", "body", ",", "special", ")", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "is", "an", "operand", "that", "will", "not", "be", "affected", "by", "having", "vector", "doublewords", "swapped", "in", "memory", "(", "in", "which", "case", "*", "SPECIAL", "is", "unchanged", ")", ",", "or", "that", "can", "be", "modified", "to", "be", "correct", "if", "vector", "doublewords", "are", "swapped", "in", "memory", "(", "in", "which", "case", "*", "SPECIAL", "is", "changed", "to", "a", "value", "indicating", "how", ")", "." ]

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

[]

[ "<s>", "static", "struct", "machine_function", "*", "arm_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "func_type", "=", "ARM_FT_UNKNOWN", ";", "return", "machine", ";", "}", "</s>" ]

[ "Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "indirectable_constant_address_p", "(", "rtx", "x", ",", "bool", "indirect", "ATTRIBUTE_UNUSED", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "x", ")", ";", "}", "</s>" ]

[ "Re-definition", "of", "CONSTANT_ADDRESS_P", ",", "which", "is", "true", "only", "when", "there", "are", "no", "SYMBOL_REFs", "for", "external", "symbols", "present", "." ]

[ "vax" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_sel", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "int", "unit_size", "=", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ";", "if", "(", "d", "->", "vec_flags", "!=", "VEC_SVE_DATA", "||", "unit_size", ">", "8", ")", "return", "false", ";", "int", "n_patterns", "=", "d", "->", "perm", ".", "encoding", "(", ")", ".", "npatterns", "(", ")", ";", "poly_int64", "vec_len", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_patterns", ";", "++", "i", ")", "if", "(", "!", "known_eq", "(", "d", "->", "perm", "[", "i", "]", ",", "i", ")", "&&", "!", "known_eq", "(", "d", "->", "perm", "[", "i", "]", ",", "vec_len", "+", "i", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "n_patterns", ";", "i", "<", "n_patterns", "*", "2", ";", "i", "++", ")", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "i", ",", "n_patterns", ",", "i", ",", "n_patterns", ")", "&&", "!", "d", "->", "perm", ".", "series_p", "(", "i", ",", "n_patterns", ",", "vec_len", "+", "i", ",", "n_patterns", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "machine_mode", "pred_mode", "=", "aarch64_sve_pred_mode", "(", "vmode", ")", ";", "rtx_vector_builder", "builder", "(", "pred_mode", ",", "n_patterns", ",", "2", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_patterns", "*", "2", ";", "i", "++", ")", "{", "rtx", "elem", "=", "known_eq", "(", "d", "->", "perm", "[", "i", "]", ",", "i", ")", "?", "CONST1_RTX", "(", "BImode", ")", ":", "CONST0_RTX", "(", "BImode", ")", ";", "builder", ".", "quick_push", "(", "elem", ")", ";", "}", "rtx", "const_vec", "=", "builder", ".", "build", "(", ")", ";", "rtx", "pred", "=", "force_reg", "(", "pred_mode", ",", "const_vec", ")", ";", "emit_insn", "(", "gen_vcond_mask", "(", "vmode", ",", "vmode", ",", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "pred", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "implement", "D", "using", "SVE", "SEL", "instruction", "." ]

[ "aarch64", "8", "0", "2", "2", "0", "2" ]

[]

[ "<s>", "void", "mips_expand_atomic_qihi", "(", "union", "mips_gen_fn_ptrs", "generator", ",", "rtx", "result", ",", "rtx", "mem", ",", "rtx", "oldval", ",", "rtx", "newval", ")", "{", "rtx", "orig_addr", ",", "memsi_addr", ",", "memsi", ",", "shift", ",", "shiftsi", ",", "unshifted_mask", ";", "rtx", "unshifted_mask_reg", ",", "mask", ",", "inverted_mask", ",", "si_op", ";", "rtx", "res", "=", "NULL", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "orig_addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "memsi_addr", "=", "mips_force_binary", "(", "Pmode", ",", "AND", ",", "orig_addr", ",", "force_reg", "(", "Pmode", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "memsi_addr", ")", ";", "set_mem_alias_set", "(", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "MEM_VOLATILE_P", "(", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "shift", "=", "mips_force_binary", "(", "Pmode", ",", "AND", ",", "orig_addr", ",", "GEN_INT", "(", "3", ")", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "mips_emit_binary", "(", "XOR", ",", "shift", ",", "shift", ",", "GEN_INT", "(", "mode", "==", "QImode", "?", "3", ":", "2", ")", ")", ";", "mips_emit_binary", "(", "ASHIFT", ",", "shift", ",", "shift", ",", "GEN_INT", "(", "3", ")", ")", ";", "shiftsi", "=", "force_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "shift", ")", ")", ";", "unshifted_mask", "=", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ";", "unshifted_mask_reg", "=", "force_reg", "(", "SImode", ",", "unshifted_mask", ")", ";", "mask", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "unshifted_mask_reg", ",", "shiftsi", ")", ";", "inverted_mask", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "inverted_mask", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ")", ";", "if", "(", "oldval", "!=", "const0_rtx", ")", "{", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "oldval", "=", "force_reg", "(", "SImode", ",", "oldval", ")", ";", "oldval", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "oldval", ",", "shiftsi", ")", ";", "}", "if", "(", "newval", "&&", "newval", "!=", "const0_rtx", ")", "{", "newval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "newval", ",", "true", ")", ";", "newval", "=", "force_reg", "(", "SImode", ",", "newval", ")", ";", "newval", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "newval", ",", "shiftsi", ")", ";", "}", "if", "(", "result", ")", "res", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "newval", ")", "si_op", "=", "generator", ".", "fn_6", "(", "res", ",", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ",", "newval", ")", ";", "else", "if", "(", "result", ")", "si_op", "=", "generator", ".", "fn_5", "(", "res", ",", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ")", ";", "else", "si_op", "=", "generator", ".", "fn_4", "(", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ")", ";", "emit_insn", "(", "si_op", ")", ";", "if", "(", "result", ")", "{", "mips_emit_binary", "(", "AND", ",", "res", ",", "res", ",", "mask", ")", ";", "mips_emit_binary", "(", "LSHIFTRT", ",", "res", ",", "res", ",", "shiftsi", ")", ";", "mips_emit_move", "(", "result", ",", "gen_lowpart", "(", "GET_MODE", "(", "result", ")", ",", "res", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "QI", "or", "HI", "mode", "atomic", "memory", "operation", ".", "GENERATOR", "contains", "a", "pointer", "to", "the", "gen_", "*", "function", "that", "generates", "the", "SI", "mode", "underlying", "atomic", "operation", "using", "masks", "that", "we", "calculate", ".", "RESULT", "is", "the", "return", "register", "for", "the", "operation", ".", "Its", "value", "is", "NULL", "if", "unused", ".", "MEM", "is", "the", "location", "of", "the", "atomic", "access", ".", "OLDVAL", "is", "the", "first", "operand", "for", "the", "operation", ".", "NEWVAL", "is", "the", "optional", "second", "operand", "for", "the", "operation", ".", "Its", "value", "is", "NULL", "if", "unused", "." ]

[ "mips", "0", "4", "3", "3", "2", "3" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_GEP", ":", "case", "G_AND", ":", "case", "G_OR", ":", "case", "G_XOR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_LSHR", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "case", "G_GLOBAL_VALUE", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "bool", "NVPTXDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "SelectDirectAddr", "(", "Op", ",", "Op0", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "if", "(", "SelectADDRri", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Lanai", "Lanai", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"", "0", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getGOT", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"AArch64TargetLowering::getGOT\\n\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "GotAddr", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_GOT", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "LOADgot", ",", "DL", ",", "Ty", ",", "GotAddr", ")", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ "AArch64", "AArch64", "\"AArch64TargetLowering::getGOT\\n\"", "AArch64II::MO_GOT", "AArch64ISD::LOADgot" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "useHVXOps", "(", ")", ")", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Hexagon_HVX", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "arm_rtx_shift_left_p", "(", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "MULT", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ">", "0", ")", "return", "true", ";", "if", "(", "code", "==", "ASHIFT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "either", "an", "arithmetic", "shift", "left", ",", "or", "is", "a", "multiplication", "by", "a", "power", "of", "two", "." ]

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

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOperations", ",", "bool", "ForCodeSize", ",", "NegatibleCost", "&", "Cost", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FMA", ":", "case", "ISD", "::", "FMAD", ":", "{", "if", "(", "!", "allUsesHaveSourceMods", "(", "Op", ".", "getNode", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Cost", ",", "Depth", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "ISD::FMA", "ISD::FMAD" ]

[]

[ "<s>", "void", "visium_expand_epilogue", "(", "void", ")", "{", "const", "int", "save_area_size", "=", "current_frame_info", ".", "save_area_size", ";", "const", "int", "reg_size1", "=", "current_frame_info", ".", "reg_size1", ";", "const", "int", "max_reg1", "=", "current_frame_info", ".", "max_reg1", ";", "const", "int", "reg_size2", "=", "current_frame_info", ".", "reg_size2", ";", "const", "int", "var_size", "=", "current_frame_info", ".", "var_size", ";", "const", "int", "restore_fp", "=", "current_frame_info", ".", "save_fp", ";", "const", "int", "restore_lr", "=", "current_frame_info", ".", "save_lr", ";", "const", "int", "lr_slot", "=", "current_frame_info", ".", "lr_slot", ";", "const", "int", "local_frame_offset", "=", "(", "restore_fp", "+", "restore_lr", "+", "lr_slot", ")", "*", "UNITS_PER_WORD", ";", "const", "int", "combine", "=", "current_frame_info", ".", "combine", ";", "int", "reg_size", ";", "int", "last_reg", ";", "int", "fsize", ";", "if", "(", "!", "crtl", "->", "sp_is_unchanging", ")", "emit_insn", "(", "gen_stack_restore", "(", ")", ")", ";", "if", "(", "restore_fp", ")", "{", "rtx", "src", ";", "if", "(", "TARGET_MCM", "&&", "!", "crtl", "->", "sp_is_unchanging", ")", "src", "=", "gen_frame_mem", "(", "SImode", ",", "hard_frame_pointer_rtx", ")", ";", "else", "src", "=", "gen_frame_mem", "(", "SImode", ",", "stack_pointer_rtx", ")", ";", "rtx", "insn", "=", "emit_frame_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "src", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "visium_add_cfa_restore_note", "(", "hard_frame_pointer_rtx", ")", ";", "}", "if", "(", "restore_lr", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "restore_fp", "*", "UNITS_PER_WORD", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "LINK_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "visium_add_cfa_restore_note", "(", "reg", ")", ";", "}", "if", "(", "reg_size2", ")", "{", "reg_size", "=", "reg_size2", ";", "last_reg", "=", "max_reg1", "+", "1", ";", "fsize", "=", "local_frame_offset", "+", "var_size", "+", "reg_size2", ";", "}", "else", "{", "reg_size", "=", "reg_size1", ";", "last_reg", "=", "0", ";", "fsize", "=", "local_frame_offset", "+", "var_size", "+", "reg_size1", "+", "save_area_size", ";", "}", "if", "(", "reg_size", "&&", "combine", ")", "visium_restore_regs", "(", "fsize", ",", "local_frame_offset", "+", "var_size", ",", "FIRST_PSEUDO_REGISTER", "-", "1", ",", "last_reg", ")", ";", "else", "if", "(", "fsize", ")", "{", "const", "int", "pop_size", "=", "reg_size", "?", "local_frame_offset", "+", "var_size", ":", "fsize", ";", "rtx", "insn", ";", "if", "(", "pop_size", ">", "65535", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_move_insn", "(", "tmp", ",", "GEN_INT", "(", "pop_size", ")", ")", ";", "insn", "=", "emit_frame_insn", "(", "gen_stack_pop", "(", "tmp", ")", ")", ";", "}", "else", "insn", "=", "emit_frame_insn", "(", "gen_stack_pop", "(", "GEN_INT", "(", "pop_size", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "pop_size", ")", ")", ")", ")", ";", "visium_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "}", "if", "(", "reg_size", "&&", "!", "combine", ")", "visium_restore_regs", "(", "fsize", "-", "local_frame_offset", "-", "var_size", ",", "0", ",", "FIRST_PSEUDO_REGISTER", "-", "1", ",", "last_reg", ")", ";", "if", "(", "reg_size2", ")", "visium_restore_regs", "(", "reg_size1", "+", "save_area_size", ",", "0", ",", "max_reg1", ",", "0", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_stack_pop", "(", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "code", "for", "function", "exit", "." ]

[ "visium", "1", "0", "1", "65535", "0", "1", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "SystemZ", "8", "0" ]

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "EmitAllAutos", "(", "M", ")", ";", "printLibcallDecls", "(", ")", ";", "DbgInfo", ".", "EndModule", "(", "M", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\tEND\"", ")", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "\"\\tEND\"" ]

[]

[ "<s>", "bool", "aarch64_sve_dup_immediate_p", "(", "rtx", "x", ")", "{", "x", "=", "aarch64_bit_representation", "(", "unwrap_const_vec_duplicate", "(", "x", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "x", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "val", "&", "0xff", ")", "return", "IN_RANGE", "(", "val", ",", "-", "0x80", ",", "0x7f", ")", ";", "return", "IN_RANGE", "(", "val", ",", "-", "0x8000", ",", "0x7f00", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "the", "SVE", "DUP", "and", "CPY", "instructions", "." ]

[ "aarch64", "0xff", "0x80", "0x7f", "0x8000", "0x7f00" ]

[]

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

[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "powerpcspe" ]

[]

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

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

[ "CJG" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFAbsFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fabs", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "R600", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "void", "RISCVRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "Register", "FrameReg", ";", "int", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ".", "getFixed", "(", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "{", "report_fatal_error", "(", "\"Frame offsets outside of the signed 32-bit range not supported\"", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "bool", "FrameRegIsKill", "=", "false", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "Offset", ")", ")", "{", "assert", "(", "isInt", "<", "32", ">", "(", "Offset", ")", "&&", "\"Int32 expected\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "TII", "->", "movImm", "(", "MBB", ",", "II", ",", "DL", ",", "ScratchReg", ",", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "RISCV", "::", "ADD", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "FrameRegIsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "FrameRegIsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "\"Unexpected non-zero SPAdj value\"", "RISCV", "RISCV", "1", "32", "\"Frame offsets outside of the signed 32-bit range not supported\"", "12", "32", "\"Int32 expected\"", "RISCV::GPRRegClass", "RISCV::ADD", "0", "1" ]

[]

[ "<s>", "static", "bool", "mips_matching_cpu_name_p", "(", "const", "char", "*", "canonical", ",", "const", "char", "*", "given", ")", "{", "if", "(", "mips_strict_matching_cpu_name_p", "(", "canonical", ",", "given", ")", ")", "return", "true", ";", "if", "(", "TOLOWER", "(", "*", "given", ")", "==", "'r'", ")", "given", "++", ";", "if", "(", "!", "ISDIGIT", "(", "*", "given", ")", ")", "return", "false", ";", "if", "(", "TOLOWER", "(", "canonical", "[", "0", "]", ")", "==", "'v'", "&&", "TOLOWER", "(", "canonical", "[", "1", "]", ")", "==", "'r'", ")", "canonical", "+=", "2", ";", "else", "if", "(", "TOLOWER", "(", "canonical", "[", "0", "]", ")", "==", "'r'", "&&", "TOLOWER", "(", "canonical", "[", "1", "]", ")", "==", "'m'", ")", "canonical", "+=", "2", ";", "else", "if", "(", "TOLOWER", "(", "canonical", "[", "0", "]", ")", "==", "'r'", ")", "canonical", "+=", "1", ";", "return", "mips_strict_matching_cpu_name_p", "(", "canonical", ",", "given", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "GIVEN", "matches", "CANONICAL", ",", "where", "GIVEN", "is", "a", "user-supplied", "CPU", "name", ".", "We", "'ve", "traditionally", "allowed", "a", "lot", "of", "variation", "here", ".", "Note", ":", "this", "function", "is", "shared", "between", "GCC", "and", "GAS", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "RC", "==", "&", "PPC", "::", "F8RCRegClass", ")", "return", "&", "PPC", "::", "VSFRCRegClass", ";", "else", "if", "(", "RC", "==", "&", "PPC", "::", "VRRCRegClass", ")", "return", "&", "PPC", "::", "VSRCRegClass", ";", "}", "return", "TargetRegisterInfo", "::", "getLargestLegalSuperClass", "(", "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", "." ]

[ "PowerPC", "PPC", "PPC::F8RCRegClass", "PPC::VSFRCRegClass", "PPC::VRRCRegClass", "PPC::VSRCRegClass" ]

[]

[ "<s>", "bool", "mips_pad_arg_upward", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "return", "true", ";", "if", "(", "type", "!=", "0", "?", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", ":", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "return", "false", ";", "if", "(", "mips_abi", "==", "ABI_O64", ")", "if", "(", "type", "!=", "0", "?", "FLOAT_TYPE_P", "(", "type", ")", ":", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "false", ";", "if", "(", "mips_abi", "!=", "ABI_EABI", ")", "return", "true", ";", "if", "(", "mode", "!=", "BLKmode", ")", "return", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">=", "PARM_BOUNDARY", ")", ";", "else", "return", "(", "int_size_in_bytes", "(", "type", ")", ">=", "(", "PARM_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUNCTION_ARG_PADDING", "(", "MODE", ",", "TYPE", ")", "should", "return", "upward", "rather", "than", "downward", ".", "In", "other", "words", ",", "return", "true", "if", "the", "first", "byte", "of", "the", "stack", "slot", "has", "useful", "data", ",", "false", "if", "the", "last", "byte", "does", "." ]

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

[]

[ "<s>", "virtual", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "mproc" ]

[]

[ "<s>", "Optional", "<", "ParamLoadedValue", ">", "ARMBaseInstrInfo", "::", "describeLoadedValue", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "const", "{", "if", "(", "auto", "DstSrcPair", "=", "isCopyInstrImpl", "(", "MI", ")", ")", "{", "Register", "DstReg", "=", "DstSrcPair", "->", "Destination", "->", "getReg", "(", ")", ";", "if", "(", "DstReg", "!=", "Reg", ")", "return", "None", ";", "}", "return", "TargetInstrInfo", "::", "describeLoadedValue", "(", "MI", ",", "Reg", ")", ";", "}", "</s>" ]

[ "Produce", "the", "expression", "describing", "the", "MI", "loading", "a", "value", "into", "the", "physical", "register", "Reg", "." ]

[ "ARM", "ARM" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "VE" ]

[]

[ "<s>", "static", "bool", "cortex_a9_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep", ",", "int", "*", "cost", ")", "{", "switch", "(", "REG_NOTE_KIND", "(", "link", ")", ")", "{", "case", "REG_DEP_ANTI", ":", "*", "cost", "=", "0", ";", "return", "false", ";", "case", "REG_DEP_TRUE", ":", "case", "REG_DEP_OUTPUT", ":", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "recog_memoized", "(", "dep", ")", ">=", "0", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "==", "MODE_FLOAT", ")", "{", "enum", "attr_type", "attr_type_insn", "=", "get_attr_type", "(", "insn", ")", ";", "enum", "attr_type", "attr_type_dep", "=", "get_attr_type", "(", "dep", ")", ";", "if", "(", "REG_P", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", "&&", "reg_set_p", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ",", "dep", ")", ")", "{", "if", "(", "(", "attr_type_insn", "==", "TYPE_FMACS", "||", "attr_type_insn", "==", "TYPE_FMACD", ")", "&&", "(", "attr_type_dep", "==", "TYPE_FMACS", "||", "attr_type_dep", "==", "TYPE_FMACD", ")", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", ")", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", "-", "3", ";", "else", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", ";", "return", "false", ";", "}", "else", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", ")", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", "+", "1", ";", "else", "*", "cost", "=", "insn_default_latency", "(", "dep", ")", ";", "}", "return", "false", ";", "}", "}", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Adjust", "cost", "hook", "for", "Cortex", "A9", "." ]

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

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "getFrameIndexOffset", "(", "MF", ",", "FI", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "TLCS900", "TLCS900", "TLCS900" ]

[]

[ "<s>", "MCELFStreamer", "&", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "SNES" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "STWFI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::STWFI", "0" ]

[]

[ "<s>", "int", "rs6000_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "if", "(", "TARGET_PREFIXED", "&&", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "USE", "&&", "GET_CODE", "(", "pattern", ")", "!=", "CLOBBER", "&&", "get_attr_prefixed", "(", "insn", ")", "==", "PREFIXED_YES", ")", "{", "int", "num_prefixed", "=", "get_attr_max_prefixed_insns", "(", "insn", ")", ";", "length", "+=", "4", "*", "(", "num_prefixed", "+", "1", ")", ";", "}", "}", "return", "length", ";", "}", "</s>" ]

[ "Adjust", "the", "length", "of", "an", "INSN", ".", "LENGTH", "is", "the", "currently-computed", "length", "and", "should", "be", "adjusted", "to", "reflect", "any", "required", "changes", ".", "This", "macro", "is", "used", "when", "there", "is", "some", "systematic", "length", "adjustment", "required", "that", "would", "be", "difficult", "to", "express", "in", "the", "length", "attribute", ".", "In", "the", "PowerPC", ",", "we", "use", "this", "to", "adjust", "the", "length", "of", "an", "instruction", "if", "one", "or", "more", "prefixed", "instructions", "are", "generated", ",", "using", "the", "attribute", "num_prefixed_insns", ".", "A", "prefixed", "instruction", "is", "8", "bytes", "instead", "of", "4", ",", "but", "the", "hardware", "requires", "that", "a", "prefied", "instruciton", "does", "not", "cross", "a", "64-byte", "boundary", ".", "This", "means", "the", "compiler", "has", "to", "assume", "the", "length", "of", "the", "first", "prefixed", "instruction", "is", "12", "bytes", "instead", "of", "8", "bytes", ".", "Since", "the", "length", "is", "already", "set", "for", "the", "non-prefixed", "instruction", ",", "we", "just", "need", "to", "udpate", "for", "the", "difference", "." ]

[ "rs6000", "4", "1" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "if", "(", "Vector", ")", "{", "return", "0", ";", "}", "return", "12", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "XCore", "0", "12" ]

[]

[ "<s>", "BitVector", "PatmosRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S1", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SL", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SH", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S4", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SS", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "ST", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SRO", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SXB", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SXO", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S11", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S12", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S13", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S14", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S15", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RSP", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RFP", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RTR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "Patmos", "::", "RFP", ")", ";", "if", "(", "PatmosSinglePathInfo", "::", "isEnabled", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "Patmos", "::", "R26", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P6", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P7", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::R0", "Patmos::P0", "Patmos::S0", "Patmos::S1", "Patmos::SL", "Patmos::SH", "Patmos::S4", "Patmos::SS", "Patmos::ST", "Patmos::SRB", "Patmos::SRO", "Patmos::SXB", "Patmos::SXO", "Patmos::S11", "Patmos::S12", "Patmos::S13", "Patmos::S14", "Patmos::S15", "Patmos::RSP", "Patmos::RFP", "Patmos::RTR", "Patmos::RFP", "Patmos", "Patmos::R26", "Patmos::P6", "Patmos::P7" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addFastRegAlloc", "(", ")", "{", "addPass", "(", "&", "PHIEliminationID", ")", ";", "addPass", "(", "&", "TwoAddressInstructionPassID", ")", ";", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "CSKYAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "!", "InConstantPool", ")", "return", ";", "InConstantPool", "=", "false", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addOperand", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addOperand", "(", "Cond", "[", "1", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "0", "WebAssembly::BR_IF", "1", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "void", "unicosmk_output_align", "(", "FILE", "*", "file", ",", "int", "align", ")", "{", "if", "(", "inside_function", ")", "fprintf", "(", "file", ",", "\"\\tgcc@code@align\\t%d\\n\"", ",", "align", ")", ";", "else", "fprintf", "(", "file", ",", "\"\\t.align\\t%d\\n\"", ",", "align", ")", ";", "}", "</s>" ]

[ "Output", "an", "alignment", "directive", ".", "We", "have", "to", "use", "the", "macro", "'gcc", "@", "code", "@", "align", "'", "in", "code", "sections", "because", ".align", "fill", "unused", "space", "with", "zeroes", "." ]

[ "alpha", "\"\\tgcc@code@align\\t%d\\n\"", "\"\\t.align\\t%d\\n\"" ]

[]

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

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

[ "Sparc", "MVT::i32" ]

[]

[ "<s>", "void", "ARMConstantPoolValue", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "if", "(", "GV", ")", "O", "<<", "GV", "->", "getName", "(", ")", ";", "else", "O", "<<", "S", ";", "if", "(", "Modifier", ")", "O", "<<", "\"(\"", "<<", "Modifier", "<<", "\")\"", ";", "if", "(", "PCAdjust", "!=", "0", ")", "{", "O", "<<", "\"-(LPC\"", "<<", "LabelId", "<<", "\"+\"", "<<", "(", "unsigned", ")", "PCAdjust", ";", "if", "(", "AddCurrentAddress", ")", "O", "<<", "\"-.\"", ";", "O", "<<", "\")\"", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"(\"", "\")\"", "0", "\"-(LPC\"", "\"+\"", "\"-.\"", "\")\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", "Alignment", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "AllowsUnaligned", "=", "Subtarget", "->", "allowsUnalignedMem", "(", ")", ";", "auto", "Ty", "=", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ";", "if", "(", "Ty", "==", "MVT", "::", "i8", "||", "Ty", "==", "MVT", "::", "i16", "||", "Ty", "==", "MVT", "::", "i32", ")", "{", "if", "(", "AllowsUnaligned", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "Subtarget", "->", "hasV7Ops", "(", ")", ";", "return", "true", ";", "}", "}", "if", "(", "Ty", "==", "MVT", "::", "f64", "||", "Ty", "==", "MVT", "::", "v2f64", ")", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "AllowsUnaligned", "||", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "}", "if", "(", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "(", "Ty", "==", "MVT", "::", "v16i1", "||", "Ty", "==", "MVT", "::", "v8i1", "||", "Ty", "==", "MVT", "::", "v4i1", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Ty", "!=", "MVT", "::", "v16i8", "&&", "Ty", "!=", "MVT", "::", "v8i16", "&&", "Ty", "!=", "MVT", "::", "v8f16", "&&", "Ty", "!=", "MVT", "::", "v4i32", "&&", "Ty", "!=", "MVT", "::", "v4f32", "&&", "Ty", "!=", "MVT", "::", "v2i64", "&&", "Ty", "!=", "MVT", "::", "v2f64", "&&", "Ty", "!=", "MVT", "::", "v4i8", "&&", "Ty", "!=", "MVT", "::", "v8i8", "&&", "Ty", "!=", "MVT", "::", "v4i16", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isLittle", "(", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "else", "{", "if", "(", "Ty", "==", "MVT", "::", "v16i8", "||", "(", "(", "Ty", "==", "MVT", "::", "v8i16", "||", "Ty", "==", "MVT", "::", "v8f16", ")", "&&", "Alignment", ">=", "2", ")", "||", "(", "(", "Ty", "==", "MVT", "::", "v4i32", "||", "Ty", "==", "MVT", "::", "v4f32", ")", "&&", "Alignment", ">=", "4", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f64", "MVT::v2f64", "MVT::v16i1", "MVT::v8i1", "MVT::v4i1", "MVT::v16i8", "MVT::v8i16", "MVT::v8f16", "MVT::v4i32", "MVT::v4f32", "MVT::v2i64", "MVT::v2f64", "MVT::v4i8", "MVT::v8i8", "MVT::v4i16", "MVT::v16i8", "MVT::v8i16", "MVT::v8f16", "2", "MVT::v4i32", "MVT::v4f32", "4" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCSubtargetInfo", "&", "NewSTI", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getSubtargetCopy", "(", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ")", ";", "NewSTI", ".", "setFeatureBits", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "STI", "=", "&", "NewSTI", ";", "SetupMachineFunction", "(", "MF", ")", ";", "emitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "int", "sh_loop_align", "(", "rtx_insn", "*", "label", ")", "{", "rtx_insn", "*", "next", "=", "label", ";", "if", "(", "!", "optimize", "||", "optimize_size", ")", "return", "0", ";", "do", "next", "=", "next_nonnote_insn", "(", "next", ")", ";", "while", "(", "next", "&&", "LABEL_P", "(", "next", ")", ")", ";", "if", "(", "!", "next", "||", "!", "INSN_P", "(", "next", ")", "||", "recog_memoized", "(", "next", ")", "==", "CODE_FOR_consttable_2", ")", "return", "0", ";", "return", "align_loops_log", ";", "}", "</s>" ]

[ "If", "we", "are", "inside", "a", "phony", "loop", ",", "almost", "any", "kind", "of", "label", "can", "turn", "up", "as", "the", "first", "one", "in", "the", "loop", ".", "Aligning", "a", "braf", "label", "causes", "incorrect", "switch", "destination", "addresses", ";", "we", "can", "detect", "braf", "labels", "because", "they", "are", "followed", "by", "a", "BARRIER", ".", "Applying", "loop", "alignment", "to", "small", "constant", "or", "switch", "tables", "is", "a", "waste", "of", "space", ",", "so", "we", "suppress", "this", "too", "." ]

[ "sh", "0", "0" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "LegalizerHelper", "&", "Helper", ",", "MachineInstr", "&", "MI", ")", "const", "{", "MachineIRBuilder", "&", "MIRBuilder", "=", "Helper", ".", "MIRBuilder", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "MIRBuilder", ".", "getMRI", "(", ")", ";", "GISelChangeObserver", "&", "Observer", "=", "Helper", ".", "Observer", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "legalizeLoadStore", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "legalizeShlAshrLshr", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeSmallCMGlobalValue", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vector_init_one_var", "(", "bool", "mmx_ok", ",", "enum", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "vals", ",", "int", "one_var", ")", "{", "rtx", "var", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ";", "enum", "machine_mode", "wmode", ";", "rtx", "const_vec", ",", "x", ";", "const_vec", "=", "copy_rtx", "(", "vals", ")", ";", "XVECEXP", "(", "const_vec", ",", "0", ",", "one_var", ")", "=", "CONST0_RTX", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "const_vec", ",", "0", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "V2DFmode", ":", "case", "V2DImode", ":", "case", "V2SFmode", ":", "case", "V2SImode", ":", "return", "false", ";", "case", "V4SFmode", ":", "case", "V4SImode", ":", "case", "V8HImode", ":", "case", "V4HImode", ":", "break", ";", "case", "V16QImode", ":", "wmode", "=", "V8HImode", ";", "goto", "widen", ";", "case", "V8QImode", ":", "wmode", "=", "V4HImode", ";", "goto", "widen", ";", "widen", ":", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", "^", "1", ")", ";", "if", "(", "one_var", "&", "1", ")", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "var", "=", "expand_simple_binop", "(", "HImode", ",", "ASHIFT", ",", "var", ",", "GEN_INT", "(", "8", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "GEN_INT", "(", "INTVAL", "(", "x", ")", "&", "0xff", ")", ";", "}", "else", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "x", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "<<", "8", ",", "HImode", ")", ";", "}", "if", "(", "x", "!=", "const0_rtx", ")", "var", "=", "expand_simple_binop", "(", "HImode", ",", "IOR", ",", "var", ",", "x", ",", "var", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "emit_move_insn", "(", "x", ",", "gen_lowpart", "(", "wmode", ",", "const_vec", ")", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "x", ",", "var", ",", "one_var", ">>", "1", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "x", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "emit_move_insn", "(", "target", ",", "const_vec", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "target", ",", "var", ",", "one_var", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vector_init", ".", "Store", "into", "TARGET", "a", "vector", "consisting", "of", "the", "values", "in", "VALS", ".", "It", "is", "known", "that", "all", "elements", "except", "ONE_VAR", "are", "constants", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "0", "0", "0", "0", "1", "1", "8", "1", "0xff", "8", "1", "1" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "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", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getMMI", "(", ")", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "if", "(", "Amount", ")", "{", "int", "Offset", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "if", "(", "!", "(", "Fn", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ",", "false", ")", ";", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "int", "CFAOffset", "=", "Amount", ";", "if", "(", "CFAOffset", ")", "{", "CFAOffset", "=", "isDestroy", "?", "-", "CFAOffset", ":", "CFAOffset", ";", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CFAOffset", ")", ")", ";", "}", "}", "return", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "}", "</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", "0", "0", "1", "0", "X86", "0" ]

[]

[ "<s>", "uint32_t", "AMDGPUTargetLowering", "::", "getImplicitParameterOffset", "(", "const", "AMDGPUMachineFunction", "*", "MFI", ",", "const", "ImplicitParameter", "Param", ")", "const", "{", "uint64_t", "ArgOffset", "=", "MFI", "->", "ABIArgOffset", ";", "switch", "(", "Param", ")", "{", "case", "GRID_DIM", ":", "return", "ArgOffset", ";", "case", "GRID_OFFSET", ":", "return", "ArgOffset", "+", "4", ";", "}", "llvm_unreachable", "(", "\"unexpected implicit parameter type\"", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "returns", "the", "byte", "offset", "of", "the", "given", "type", "of", "implicit", "parameter", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "4", "\"unexpected implicit parameter type\"" ]

[]

[ "<s>", "static", "bool", "cdxreg", "(", "rtx", "op", ")", "{", "return", "REG_P", "(", "op", ")", "&&", "(", "!", "reload_completed", "||", "CDX_REG_P", "(", "REGNO", "(", "op", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "a", "REG", "and", "assigned", "a", "CDX", "reg", "." ]

[ "nios2" ]

[]

[ "<s>", "void", "rvexAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"MI:\"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"MI bundle:\"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "std", "::", "vector", "<", "const", "MachineInstr", "*", ">", "BundleMIs", ";", "unsigned", "int", "IgnoreCount", "=", "0", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MBBe", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "++", "MII", ";", "while", "(", "MII", "!=", "MBBe", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "const", "MachineInstr", "*", "MInst", "=", "MII", ";", "if", "(", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "{", "IgnoreCount", "++", ";", "}", "else", "{", "BundleMIs", ".", "push_back", "(", "MInst", ")", ";", "}", "++", "MII", ";", "}", "unsigned", "Size", "=", "BundleMIs", ".", "size", "(", ")", ";", "assert", "(", "(", "Size", "+", "IgnoreCount", ")", "==", "MI", "->", "getBundleSize", "(", ")", "&&", "\"Corrupt Bundle!\"", ")", ";", "for", "(", "unsigned", "Index", "=", "0", ";", "Index", "<", "Size", ";", "++", "Index", ")", "{", "const", "MachineInstr", "*", "BMI", "=", "BundleMIs", "[", "Index", "]", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "BMI", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"inst:\"", "<<", "TmpInst0", "<<", "\"\\n\"", ")", ";", "}", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\";;\\n\\n\"", ")", ")", ";", "}", "else", "{", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\";;\\n\\n\"", ")", ")", ";", "}", "}", "</s>" ]

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

[ "rvex", "rvex", "128", "\"MI:\"", "\"\\n\"", "\"MI bundle:\"", "\"\\n\"", "0", "\"Corrupt Bundle!\"", "0", "\"inst:\"", "\"\\n\"", "\";;\\n\\n\"", "\";;\\n\\n\"" ]

[]

[ "<s>", "static", "void", "riscv_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "unsigned", "HOST_WIDE_INT", "length", ",", "unsigned", "HOST_WIDE_INT", "bytes_per_iter", ")", "{", "rtx", "label", ",", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "unsigned", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "bytes_per_iter", ";", "length", "-=", "leftover", ";", "riscv_adjust_block_mem", "(", "src", ",", "bytes_per_iter", ",", "&", "src_reg", ",", "&", "src", ")", ";", "riscv_adjust_block_mem", "(", "dest", ",", "bytes_per_iter", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "riscv_block_move_straight", "(", "dest", ",", "src", ",", "bytes_per_iter", ")", ";", "riscv_emit_move", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "bytes_per_iter", ")", ")", ";", "riscv_emit_move", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "bytes_per_iter", ")", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_jump_insn", "(", "gen_cbranchdi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_cbranchsi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "if", "(", "leftover", ")", "riscv_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "else", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "BYTES_PER_ITER", "bytes", "at", "a", "time", ".", "LENGTH", "must", "be", "at", "least", "BYTES_PER_ITER", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

[ "riscv", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "arm_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "(", "regno", "==", "CC_REGNUM", "||", "(", "TARGET_VFP_BASE", "&&", "regno", "==", "VFPCC_REGNUM", ")", ")", ";", "if", "(", "regno", "==", "CC_REGNUM", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "IS_VPR_REGNUM", "(", "regno", ")", ")", "return", "VALID_MVE_PRED_MODE", "(", "mode", ")", ";", "if", "(", "TARGET_THUMB1", ")", "return", "(", "ARM_NUM_REGS", "(", "mode", ")", "<", "2", ")", "||", "(", "regno", "<", "LAST_LO_REGNUM", ")", ";", "if", "(", "TARGET_VFP_BASE", "&&", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "return", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ";", "if", "(", "mode", "==", "HFmode", "||", "mode", "==", "BFmode", "||", "mode", "==", "HImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "if", "(", "TARGET_NEON", ")", "return", "(", "VALID_NEON_DREG_MODE", "(", "mode", ")", "&&", "VFP_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ")", "||", "(", "VALID_NEON_QREG_MODE", "(", "mode", ")", "&&", "NEON_REGNO_OK_FOR_QUAD", "(", "regno", ")", ")", "||", "(", "mode", "==", "TImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "2", ")", ")", "||", "(", "mode", "==", "EImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "3", ")", ")", "||", "(", "mode", "==", "OImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "4", ")", ")", "||", "(", "mode", "==", "CImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "6", ")", ")", "||", "(", "mode", "==", "XImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "8", ")", ")", ";", "if", "(", "TARGET_HAVE_MVE", ")", "return", "(", "(", "VALID_MVE_MODE", "(", "mode", ")", "&&", "NEON_REGNO_OK_FOR_QUAD", "(", "regno", ")", ")", "||", "(", "mode", "==", "OImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "4", ")", ")", "||", "(", "mode", "==", "XImode", "&&", "NEON_REGNO_OK_FOR_NREGS", "(", "regno", ",", "8", ")", ")", ")", ";", "return", "false", ";", "}", "if", "(", "TARGET_REALLY_IWMMXT", ")", "{", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "VALID_IWMMXT_REG_MODE", "(", "mode", ")", ";", "}", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", ")", "{", "if", "(", "ARM_NUM_REGS", "(", "mode", ")", ">", "4", ")", "return", "false", ";", "if", "(", "TARGET_THUMB2", "&&", "!", "(", "TARGET_HAVE_MVE", "||", "TARGET_CDE", ")", ")", "return", "true", ";", "return", "!", "(", "(", "TARGET_LDRD", "||", "TARGET_CDE", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "}", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "REGNO", "is", "a", "valid", "register", "for", "holding", "a", "quantity", "of", "type", "MODE", "." ]

[ "arm", "2", "2", "3", "4", "6", "8", "4", "8", "4", "4", "1", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MipsRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "CSR_SingleFloatOnly_SaveList", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", "return", "CSR_N64_SaveList", ";", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "CSR_N32_SaveList", ";", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "return", "CSR_O32_FP64_SaveList", ";", "if", "(", "Subtarget", ".", "isFPXX", "(", ")", ")", "return", "CSR_O32_FPXX_SaveList", ";", "return", "CSR_O32_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "mips_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "if", "(", "length", "==", "MAX_PIC_BRANCH_LENGTH", "&&", "JUMP_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", ">=", "0", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_BRANCH", ")", "{", "length", "=", "simplejump_p", "(", "insn", ")", "?", "0", ":", "8", ";", "length", "+=", "BASE_INSN_LENGTH", "*", "mips_load_label_num_insns", "(", ")", ";", "length", "+=", "TARGET_COMPRESSION", "?", "2", ":", "4", ";", "}", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "TARGET_MIPS16", "?", "simplejump_p", "(", "insn", ")", ":", "JUMP_P", "(", "insn", ")", ")", ")", "length", "+=", "TARGET_MIPS16", "?", "2", ":", "4", ";", "if", "(", "!", "cfun", "->", "machine", "->", "ignore_hazard_length_p", "&&", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_DELAY", ":", "length", "+=", "NOP_INSN_LENGTH", ";", "break", ";", "case", "HAZARD_HILO", ":", "length", "+=", "NOP_INSN_LENGTH", "*", "2", ";", "break", ";", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", "." ]

[ "mips", "0", "0", "8", "2", "4", "2", "4", "0", "2" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "!", "MIa", ".", "hasOneMemOperand", "(", ")", "||", "!", "MIb", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "MachineMemOperand", "*", "MMOa", "=", "*", "MIa", ".", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "MMOb", "=", "*", "MIb", ".", "memoperands_begin", "(", ")", ";", "const", "Value", "*", "VALa", "=", "MMOa", "->", "getValue", "(", ")", ";", "const", "Value", "*", "VALb", "=", "MMOb", "->", "getValue", "(", ")", ";", "bool", "SameVal", "=", "(", "VALa", "&&", "VALb", "&&", "(", "VALa", "==", "VALb", ")", ")", ";", "if", "(", "!", "SameVal", ")", "{", "const", "PseudoSourceValue", "*", "PSVa", "=", "MMOa", "->", "getPseudoValue", "(", ")", ";", "const", "PseudoSourceValue", "*", "PSVb", "=", "MMOb", "->", "getPseudoValue", "(", ")", ";", "if", "(", "PSVa", "&&", "PSVb", "&&", "(", "PSVa", "==", "PSVb", ")", ")", "SameVal", "=", "true", ";", "}", "if", "(", "SameVal", ")", "{", "int", "OffsetA", "=", "MMOa", "->", "getOffset", "(", ")", ",", "OffsetB", "=", "MMOb", "->", "getOffset", "(", ")", ";", "int", "WidthA", "=", "MMOa", "->", "getSize", "(", ")", ",", "WidthB", "=", "MMOb", "->", "getSize", "(", ")", ";", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "RETURN", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "SETREG", ")", "NODE_NAME_CASE", "(", "FMA_W_CHAIN", ")", "NODE_NAME_CASE", "(", "FMUL_W_CHAIN", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "FMAD_FTZ", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MULHI_U24", ")", "NODE_NAME_CASE", "(", "MULHI_I24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_U24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "EXPORT_DONE", ")", "NODE_NAME_CASE", "(", "R600_EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "CVT_PKRTZ_F16_F32", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "KILL", ")", "NODE_NAME_CASE", "(", "DUMMY_CHAIN", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "SENDMSGHALT", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "R600", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "inline", "iterator_range", "<", "block_iterator", ">", "blocks", "(", ")", "const", "{", "return", "make_range", "(", "block_begin", "(", ")", ",", "block_end", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "a", "range", "view", "of", "the", "basic", "blocks", "in", "the", "region", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "return", "lowerATOMIC_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ",", "*", "this", ",", "Subtarget", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "return", "lowerToVVP", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "VE", "VE", "\"Should not custom lower this!\"", "ISD::ATOMIC_FENCE", "ISD::ATOMIC_SWAP", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FRAMEADDR", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::LOAD", "ISD::BUILD_VECTOR", "VE", "ISD::STORE", "ISD::VASTART", "ISD::VAARG" ]

[]

[ "<s>", "static", "unsigned", "selectBinaryOp", "(", "unsigned", "GenericOpc", ",", "unsigned", "RegBankID", ",", "unsigned", "OpSize", ")", "{", "switch", "(", "RegBankID", ")", "{", "case", "AArch64", "::", "GPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRWrr", ";", "case", "TargetOpcode", "::", "G_XOR", ":", "return", "AArch64", "::", "EORWrr", ";", "case", "TargetOpcode", "::", "G_AND", ":", "return", "AArch64", "::", "ANDWrr", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "AArch64", "::", "ADDWrr", ";", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "AArch64", "::", "SUBWrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVWr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVWr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVWr", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "return", "AArch64", "::", "SDIVWr", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "return", "AArch64", "::", "UDIVWr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRXrr", ";", "case", "TargetOpcode", "::", "G_XOR", ":", "return", "AArch64", "::", "EORXrr", ";", "case", "TargetOpcode", "::", "G_AND", ":", "return", "AArch64", "::", "ANDXrr", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "AArch64", "::", "ADDXrr", ";", "case", "TargetOpcode", "::", "G_SUB", ":", "return", "AArch64", "::", "SUBXrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVXr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVXr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVXr", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "return", "AArch64", "::", "SDIVXr", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "return", "AArch64", "::", "UDIVXr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "case", "AArch64", "::", "FPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDSrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBSrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULSrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVSrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDDrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBDrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULDrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVDrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "}", ";", "return", "GenericOpc", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64::GPRRegBankID", "32", "AArch64::ORRWrr", "AArch64::EORWrr", "AArch64::ANDWrr", "AArch64::ADDWrr", "AArch64::SUBWrr", "AArch64::LSLVWr", "AArch64::LSRVWr", "AArch64::ASRVWr", "AArch64::SDIVWr", "AArch64::UDIVWr", "64", "AArch64::ORRXrr", "AArch64::EORXrr", "AArch64::ANDXrr", "AArch64::ADDXrr", "AArch64::SUBXrr", "AArch64::LSLVXr", "AArch64::LSRVXr", "AArch64::ASRVXr", "AArch64::SDIVXr", "AArch64::UDIVXr", "AArch64::FPRRegBankID", "32", "AArch64::FADDSrr", "AArch64::FSUBSrr", "AArch64::FMULSrr", "AArch64::FDIVSrr", "64", "AArch64::FADDDrr", "AArch64::FSUBDrr", "AArch64::FMULDrr", "AArch64::FDIVDrr" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Lanai", "::", "LDW_RI", ")", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::LDW_RI", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "int", "xtensa_expand_block_move", "(", "rtx", "*", "operands", ")", "{", "static", "const", "enum", "machine_mode", "mode_from_align", "[", "]", "=", "{", "VOIDmode", ",", "QImode", ",", "HImode", ",", "VOIDmode", ",", "SImode", ",", "}", ";", "rtx", "dst_mem", "=", "operands", "[", "0", "]", ";", "rtx", "src_mem", "=", "operands", "[", "1", "]", ";", "HOST_WIDE_INT", "bytes", ",", "align", ";", "int", "num_pieces", ",", "move_ratio", ";", "rtx", "temp", "[", "2", "]", ";", "enum", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "if", "(", "!", "optimize", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", ")", "return", "0", ";", "bytes", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "0", ";", "if", "(", "align", ">", "MOVE_MAX", ")", "align", "=", "MOVE_MAX", ";", "move_ratio", "=", "4", ";", "if", "(", "optimize", ">", "2", ")", "move_ratio", "=", "LARGEST_MOVE_RATIO", ";", "num_pieces", "=", "(", "bytes", "/", "align", ")", "+", "(", "bytes", "%", "align", ")", ";", "if", "(", "num_pieces", ">", "move_ratio", ")", "return", "0", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "bytes", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "bytes", ">=", "4", "?", "4", ":", "(", "bytes", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", "[", "next", "]", ",", "x", ")", ")", ";", "offset_ld", "+=", "next_amount", ";", "bytes", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "temp", "[", "phase", "]", ")", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Try", "to", "expand", "a", "block", "move", "operation", "to", "an", "RTL", "block", "move", "instruction", ".", "If", "not", "optimizing", "or", "if", "the", "block", "size", "is", "not", "a", "constant", "or", "if", "the", "block", "is", "small", ",", "the", "expansion", "fails", "and", "GCC", "falls", "back", "to", "calling", "memcpy", "(", ")", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "source", "operands", "[", "2", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "DivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MemoryDependenceWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "mips_expand_before_return", "(", "void", ")", "{", "if", "(", "TARGET_CALL_CLOBBERED_GP", ")", "emit_clobber", "(", "pic_offset_table_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "any", "instructions", "needed", "before", "a", "return", "." ]

[ "mips" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createRISCVMergeBaseOffsetOptPass", "(", ")", ")", ";", "addPass", "(", "createRISCVInsertVSETVLIPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARMELFStreamer", "::", "finishImpl", "(", ")", "{", "MCTargetStreamer", "&", "TS", "=", "*", "getTargetStreamer", "(", ")", ";", "ARMTargetStreamer", "&", "ATS", "=", "static_cast", "<", "ARMTargetStreamer", "&", ">", "(", "TS", ")", ";", "ATS", ".", "finishAttributeSection", "(", ")", ";", "MCELFStreamer", "::", "finishImpl", "(", ")", ";", "}", "</s>" ]

[ "Streamer", "specific", "finalization", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Thumb IT blocks insertion pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"Thumb IT blocks insertion pass\"" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMILive", "*", "DAG", "=", "createGenericSchedLive", "(", "C", ")", ";", "DAG", "->", "addMutation", "(", "createX86MacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "s390_call_saved_register_used", "(", "tree", "call_expr", ")", "{", "CUMULATIVE_ARGS", "cum_v", ";", "cumulative_args_t", "cum", ";", "tree", "parameter", ";", "rtx", "parm_rtx", ";", "int", "reg", ",", "i", ";", "INIT_CUMULATIVE_ARGS", "(", "cum_v", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "cum", "=", "pack_cumulative_args", "(", "&", "cum_v", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "call_expr_nargs", "(", "call_expr", ")", ";", "i", "++", ")", "{", "parameter", "=", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "function_arg_info", "arg", "(", "TREE_TYPE", "(", "parameter", ")", ",", "true", ")", ";", "apply_pass_by_reference_rules", "(", "&", "cum_v", ",", "arg", ")", ";", "parm_rtx", "=", "s390_function_arg", "(", "cum", ",", "arg", ")", ";", "s390_function_arg_advance", "(", "cum", ",", "arg", ")", ";", "if", "(", "!", "parm_rtx", ")", "continue", ";", "if", "(", "REG_P", "(", "parm_rtx", ")", ")", "{", "for", "(", "reg", "=", "0", ";", "reg", "<", "REG_NREGS", "(", "parm_rtx", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", "+", "REGNO", "(", "parm_rtx", ")", ")", ")", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "parm_rtx", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "parm_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "r", "=", "XEXP", "(", "XVECEXP", "(", "parm_rtx", ",", "0", ",", "i", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "r", ")", ")", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "REG_NREGS", "(", "r", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", "+", "REGNO", "(", "r", ")", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "ARGUMENT_LIST", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

[ "s390", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Reloc", "::", "Model", "RM", "=", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "{", "assert", "(", "getSubtarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "getObjectFormat", "(", ")", "==", "Triple", "::", "MachO", "&&", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", ")", ";", "expandLoadStackGuard", "(", "MI", ",", "RM", ")", ";", "MI", "->", "getParent", "(", ")", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "!", "WidenVMOVS", "||", "!", "MI", "->", "isCopy", "(", ")", "||", "Subtarget", ".", "isCortexA15", "(", ")", "||", "Subtarget", ".", "isFPOnlySP", "(", ")", ")", "return", "false", ";", "unsigned", "DstRegS", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcRegS", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", "->", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "*", "MI", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", "->", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", "->", "RemoveOperand", "(", "ImpDefIdx", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MIB", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", "->", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "*", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "ARM", "ARM", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "1", "1", "1", "\"replaced by: \"" ]

[]

[ "<s>", "static", "void", "nvptx_end_call_args", "(", "void", ")", "{", "cfun", "->", "machine", "->", "start_call", "=", "NULL_RTX", ";", "free_EXPR_LIST_list", "(", "&", "cfun", "->", "machine", "->", "call_args", ")", ";", "}", "</s>" ]

[ "Implement", "the", "corresponding", "END_CALL_ARGS", "hook", ".", "Clear", "and", "free", "the", "information", "we", "recorded", "." ]

[ "nvptx" ]

[]

[ "<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", ";", "}", "addPass", "(", "createX86ProtectReturnSupport", "(", ")", ")", ";", "addPass", "(", "createX86ProtectSpillSupport", "(", ")", ")", ";", "addPass", "(", "createX86EnqueueExits", "(", ")", ")", ";", "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", "X86" ]

[]

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

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

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

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "bool", "isReassociationCandidate", "(", "const", "MachineInstr", "&", "Inst", ",", "bool", "&", "Commuted", ")", "{", "if", "(", "isAssociativeAndCommutative", "(", "Inst", ")", "&&", "hasReassociableOperands", "(", "Inst", ",", "Inst", ".", "getParent", "(", ")", ")", "&&", "hasReassociableSibling", "(", "Inst", ",", "Commuted", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "input", "\\P", "Inst", "is", "part", "of", "a", "chain", "of", "dependent", "ops", "that", "are", "suitable", "for", "reassociation", ",", "otherwise", "return", "false", "." ]

[ "X86" ]

[]

[ "<s>", "static", "unsigned", "long", "thumb_compute_save_reg_mask", "(", "void", ")", "{", "unsigned", "long", "mask", ";", "unsigned", "reg", ";", "mask", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "12", ";", "reg", "++", ")", "if", "(", "regs_ever_live", "[", "reg", "]", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "mask", "|=", "1", "<<", "reg", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "current_function_uses_pic_offset_table", ")", "mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "!", "frame_pointer_needed", "&&", "CALLER_INTERWORKING_SLOT_SIZE", ">", "0", ")", "mask", "|=", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "mask", "&", "0xff", "||", "thumb_force_lr_save", "(", ")", ")", "mask", "|=", "(", "1", "<<", "LR_REGNUM", ")", ";", "if", "(", "(", "mask", "&", "0xff", ")", "==", "0", "&&", "(", "(", "mask", "&", "0x0f00", ")", "||", "TARGET_BACKTRACE", ")", ")", "{", "reg", "=", "thumb_find_work_register", "(", "1", "<<", "LAST_LO_REGNUM", ")", ";", "if", "(", "!", "call_used_regs", "[", "reg", "]", ")", "mask", "|=", "1", "<<", "reg", ";", "}", "return", "mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", "." ]

[ "arm", "0", "0", "12", "1", "1", "0", "1", "0xff", "1", "0xff", "0", "0x0f00", "1", "1" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "C", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "C", ")", ")", "return", "0", ";", "assert", "(", "C", "->", "isStaticAlloca", "(", ")", "&&", "\"dynamic alloca in the static alloca map?\"", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "C", ",", "AM", ")", ")", "return", "0", ";", "unsigned", "Opc", "=", "TLI", ".", "getPointerTy", "(", "DL", ")", "==", "MVT", "::", "i32", "?", "(", "Subtarget", "->", "isTarget64BitILP32", "(", ")", "?", "X86", "::", "LEA64_32r", ":", "X86", "::", "LEA32r", ")", ":", "X86", "::", "LEA64r", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "TLI", ".", "getPointerTy", "(", "DL", ")", ")", ";", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "addFullAddress", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ",", "AM", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "X86", "X86", "0", "\"dynamic alloca in the static alloca map?\"", "X86", "X86", "0", "MVT::i32", "X86::LEA64_32r", "X86::LEA32r", "X86::LEA64r" ]

[]

[ "<s>", "bool", "BTFDebug", "::", "InstLower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "->", "getName", "(", ")", ".", "str", "(", ")", "]", ";", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "}", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_ALU32_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_SHIFT", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "3", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "->", "getName", "(", ")", ".", "str", "(", ")", "]", ";", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isImm", "(", ")", ")", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ")", ";", "else", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Emit", "proper", "patchable", "instructions", "." ]

[ "BPF", "BPF::LD_imm64", "1", "BPFCoreSharedInfo::AmaAttr", "BPF::MOV_ri", "0", "BPF::CORE_MEM", "BPF::CORE_ALU32_MEM", "BPF::CORE_SHIFT", "3", "BPFCoreSharedInfo::AmaAttr", "1", "0", "0", "0", "2" ]

[]

[ "<s>", "unsigned", "VEAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "GOp", ",", "unsigned", "Kind", ")", "{", "VEOperand", "&", "Op", "=", "(", "VEOperand", "&", ")", "GOp", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK_F32", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToF32Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_I32", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToI32Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_F128", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToF128Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_VM512", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "VEOperand", "::", "MorphToVM512Reg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_MISC", ":", "if", "(", "Op", ".", "isImm", "(", ")", "&&", "VEOperand", "::", "MorphToMISCReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "VE", "VE", "VE", "VE", "VEOperand::MorphToF32Reg", "VEOperand::MorphToI32Reg", "VEOperand::MorphToF128Reg", "VEOperand::MorphToVM512Reg", "VEOperand::MorphToMISCReg" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC", "0", "0", "\"Can only return in registers!\"", "1", "PPCISD::RET_FLAG", "MVT::Other", "PPCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "void", "function_builder", "::", "add_unique_function", "(", "const", "function_instance", "&", "instance", ",", "const", "function_shape", "*", "shape", ",", "tree", "return_type", ",", "vec", "<", "tree", ">", "&", "argument_types", ")", "{", "if", "(", "!", "check_required_extensions", "(", "instance", ")", ")", "return", ";", "char", "*", "name", "=", "shape", "->", "get_name", "(", "*", "this", ",", "instance", ",", "false", ")", ";", "tree", "fntype", "=", "build_function_type_array", "(", "return_type", ",", "argument_types", ".", "length", "(", ")", ",", "argument_types", ".", "address", "(", ")", ")", ";", "tree", "attrs", "=", "get_attributes", "(", "instance", ")", ";", "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "fntype", ",", "attrs", ",", "false", ")", ";", "hashval_t", "hash", "=", "instance", ".", "hash", "(", ")", ";", "registered_function", "*", "*", "rfn_slot", "=", "function_table", "->", "find_slot_with_hash", "(", "instance", ",", "hash", ",", "INSERT", ")", ";", "gcc_assert", "(", "!", "*", "rfn_slot", ")", ";", "*", "rfn_slot", "=", "&", "rfn", ";", "char", "*", "overload_name", "=", "shape", "->", "get_name", "(", "*", "this", ",", "instance", ",", "true", ")", ";", "if", "(", "overload_name", ")", "{", "tree", "attrs", "=", "get_attributes", "(", "instance", ")", ";", "bool", "placeholder_p", "=", "!", "m_direct_overloads", ";", "add_function", "(", "instance", ",", "overload_name", ",", "fntype", ",", "attrs", ",", "placeholder_p", ")", ";", "}", "obstack_free", "(", "&", "m_string_obstack", ",", "name", ")", ";", "}", "</s>" ]

[ "Add", "a", "built-in", "function", "for", "INSTANCE", ",", "with", "the", "argument", "types", "given", "by", "ARGUMENT_TYPES", "and", "the", "return", "type", "given", "by", "RETURN_TYPE", ".", "NAME", "is", "the", "``", "full", "''", "name", "for", "C", "function", ".", "OVERLOAD_NAME", "is", "the", "``", "short", "''", "name", "for", "C++", "overloaded", "function", ".", "OVERLOAD_NAME", "can", "be", "nullptr", "because", "some", "instance", "does", "n't", "have", "C++", "overloaded", "function", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "const", "ARMBaseTargetMachine", "&", "ARM_TM", "=", "static_cast", "<", "const", "ARMBaseTargetMachine", "&", ">", "(", "TM", ")", ";", "bool", "isAAPCS_ABI", "=", "ARM_TM", ".", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARMABI", "::", "ARM_ABI_AAPCS", ";", "genExecuteOnly", "=", "ARM_TM", ".", "getSubtargetImpl", "(", ")", "->", "genExecuteOnly", "(", ")", ";", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "isAAPCS_ABI", ")", ";", "if", "(", "isAAPCS_ABI", ")", "{", "LSDASection", "=", "nullptr", ";", "}", "AttributesSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".ARM.attributes\"", ",", "ELF", "::", "SHT_ARM_ATTRIBUTES", ",", "0", ")", ";", "if", "(", "genExecuteOnly", ")", "{", "unsigned", "Type", "=", "ELF", "::", "SHT_PROGBITS", ";", "unsigned", "Flags", "=", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_ARM_PURECODE", ";", "TextSection", "=", "Ctx", ".", "getELFSection", "(", "\".text\"", ",", "Type", ",", "Flags", ",", "0", ",", "\"\"", ",", "0U", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARMABI::ARM_ABI_AAPCS", "ARM", "\".ARM.attributes\"", "ARM", "0", "ARM", "\".text\"", "0", "\"\"", "0U" ]

[]

[ "<s>", "static", "bool", "decl_has_samegp", "(", "const_tree", "decl", ")", "{", "if", "(", "!", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "TARGET_SMALL_DATA", ")", "return", "true", ";", "return", "!", "TREE_PUBLIC", "(", "decl", ")", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "DECL", "will", "share", "the", "same", "GP", "as", "any", "function", "in", "the", "current", "unit", "of", "translation", "." ]

[ "alpha" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"RISCV gather/scatter lowering\"", ";", "}", "</s>" ]

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

[ "RISCV", "\"RISCV gather/scatter lowering\"" ]

[]

[ "<s>", "static", "void", "parse_mtune_ctrl_str", "(", "bool", "dump", ")", "{", "if", "(", "!", "ix86_tune_ctrl_string", ")", "return", ";", "char", "*", "next_feature_string", "=", "NULL", ";", "char", "*", "curr_feature_string", "=", "xstrdup", "(", "ix86_tune_ctrl_string", ")", ";", "char", "*", "orig", "=", "curr_feature_string", ";", "int", "i", ";", "do", "{", "bool", "clear", "=", "false", ";", "next_feature_string", "=", "strchr", "(", "curr_feature_string", ",", "','", ")", ";", "if", "(", "next_feature_string", ")", "*", "next_feature_string", "++", "=", "'\\0'", ";", "if", "(", "*", "curr_feature_string", "==", "'^'", ")", "{", "curr_feature_string", "++", ";", "clear", "=", "true", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "i", "++", ")", "{", "if", "(", "!", "strcmp", "(", "curr_feature_string", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ")", "{", "ix86_tune_features", "[", "i", "]", "=", "!", "clear", ";", "if", "(", "dump", ")", "fprintf", "(", "stderr", ",", "\"Explicitly %s feature %s\\n\"", ",", "clear", "?", "\"clear\"", ":", "\"set\"", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ";", "break", ";", "}", "}", "if", "(", "i", "==", "X86_TUNE_LAST", ")", "error", "(", "\"unknown parameter to option %<-mtune-ctrl%>: %s\"", ",", "clear", "?", "curr_feature_string", "-", "1", ":", "curr_feature_string", ")", ";", "curr_feature_string", "=", "next_feature_string", ";", "}", "while", "(", "curr_feature_string", ")", ";", "free", "(", "orig", ")", ";", "}", "</s>" ]

[ "parse", "-mtune-ctrl=", "option", ".", "When", "DUMP", "is", "true", ",", "print", "the", "features", "that", "are", "explicitly", "set", "." ]

[ "i386", "0", "\"Explicitly %s feature %s\\n\"", "\"clear\"", "\"set\"", "\"unknown parameter to option %<-mtune-ctrl%>: %s\"", "1" ]

[]