Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "short_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", ")", "return", "0", ";", "return", "SMALL_INT", "(", "INTVAL", "(", "op", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "short", "immediate", "(", "shimm", ")", "value", "." ]

[ "arc", "0" ]

[]

[ "<s>", "void", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "override", "{", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "DstReg", ",", "SrcReg", ",", "KillSrc", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "RISCV" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addRegBankSelect", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "register", "bank", "selector", "pass", ",", "which", "assigns", "register", "banks", "to", "virtual", "registers", "without", "a", "register", "class", "or", "register", "banks", "." ]

[ "X86", "X86" ]

[]

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

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

[ "X86", "\"Tile Register Configure\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MF", ":", "M", ")", "{", "Changed", "|=", "runOnFunction", "(", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "void", "func_fma_steering", "::", "analyze", "(", ")", "{", "int", "i", ",", "n_blocks", ",", "*", "bb_dfs_preorder", ";", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "bb_dfs_preorder", "=", "XNEWVEC", "(", "int", ",", "last_basic_block_for_fn", "(", "cfun", ")", ")", ";", "n_blocks", "=", "pre_and_rev_post_order_compute", "(", "bb_dfs_preorder", ",", "NULL", ",", "false", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_blocks", ";", "i", "++", ")", "{", "bb", "=", "BASIC_BLOCK_FOR_FN", "(", "cfun", ",", "bb_dfs_preorder", "[", "i", "]", ")", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "operand_rr_info", "*", "dest_op_info", ";", "struct", "du_chain", "*", "chain", ";", "unsigned", "dest_regno", ";", "fma_forest", "*", "forest", ";", "du_head_p", "head", ";", "int", "i", ";", "if", "(", "!", "is_fmul_fmac_insn", "(", "insn", ",", "true", ")", ")", "continue", ";", "dest_op_info", "=", "insn_rr", "[", "INSN_UID", "(", "insn", ")", "]", ".", "op_info", ";", "dest_regno", "=", "REGNO", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "dest_op_info", "->", "n_chains", ";", "i", "++", ")", "{", "if", "(", "dest_op_info", "->", "heads", "[", "i", "]", "->", "regno", "!=", "dest_regno", ")", "continue", ";", "head", "=", "dest_op_info", "->", "heads", "[", "i", "]", ";", "if", "(", "!", "head", "->", "first", ")", "head", "=", "regrename_chain_from_id", "(", "head", "->", "id", ")", ";", "forest", "=", "NULL", ";", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "{", "fma_node", "*", "*", "fma_slot", ";", "if", "(", "!", "is_fmul_fmac_insn", "(", "chain", "->", "insn", ",", "true", ")", ")", "continue", ";", "if", "(", "chain", "->", "loc", "!=", "&", "SET_DEST", "(", "PATTERN", "(", "chain", "->", "insn", ")", ")", ")", "continue", ";", "if", "(", "chain", "->", "insn", "==", "insn", ")", "break", ";", "fma_slot", "=", "this", "->", "m_insn_fma_head_map", "->", "get", "(", "chain", "->", "insn", ")", ";", "if", "(", "fma_slot", "&&", "(", "*", "fma_slot", ")", "->", "get_children", "(", ")", ")", "forest", "=", "(", "*", "fma_slot", ")", "->", "get_forest", "(", ")", ";", "}", "if", "(", "chain", ")", "break", ";", "}", "gcc_assert", "(", "i", "<", "dest_op_info", "->", "n_chains", ")", ";", "this", "->", "analyze_fma_fmul_insn", "(", "forest", ",", "chain", ",", "head", ")", ";", "}", "}", "free", "(", "bb_dfs_preorder", ")", ";", "if", "(", "dump_file", ")", "this", "->", "dfs", "(", "dump_forest_info", ",", "dump_tree_root_info", ",", "dump_tree_node_info", ",", "false", ")", ";", "}", "</s>" ]

[ "Count", "how", "many", "times", "each", "regno", "is", "referenced", "as", "base", "address", "for", "a", "memory", "access", "." ]

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

[]

[ "<s>", "static", "int", "write_arg_mode", "(", "std", "::", "stringstream", "&", "s", ",", "int", "for_reg", ",", "int", "argno", ",", "machine_mode", "mode", ")", "{", "const", "char", "*", "ptx_type", "=", "nvptx_ptx_type_from_mode", "(", "mode", ",", "false", ")", ";", "if", "(", "for_reg", "<", "0", ")", "{", "s", "<<", "(", "argno", "?", "\", \"", ":", "\" (\"", ")", ";", "s", "<<", "\".param\"", "<<", "ptx_type", "<<", "\" %in_ar\"", "<<", "argno", ";", "}", "else", "{", "s", "<<", "\"\\t.reg\"", "<<", "ptx_type", "<<", "\" \"", ";", "if", "(", "for_reg", ")", "s", "<<", "reg_names", "[", "for_reg", "]", ";", "else", "s", "<<", "\"%ar\"", "<<", "argno", ";", "s", "<<", "\";\\n\"", ";", "if", "(", "argno", ">=", "0", ")", "{", "s", "<<", "\"\\tld.param\"", "<<", "ptx_type", "<<", "\" \"", ";", "if", "(", "for_reg", ")", "s", "<<", "reg_names", "[", "for_reg", "]", ";", "else", "s", "<<", "\"%ar\"", "<<", "argno", ";", "s", "<<", "\", [%in_ar\"", "<<", "argno", "<<", "\"];\\n\"", ";", "}", "}", "return", "argno", "+", "1", ";", "}", "</s>" ]

[ "Helper", "for", "write_arg", ".", "Emit", "a", "single", "PTX", "argument", "of", "MODE", ",", "either", "in", "a", "prototype", ",", "or", "as", "copy", "in", "a", "function", "prologue", ".", "ARGNO", "is", "the", "index", "of", "this", "argument", "in", "the", "PTX", "function", ".", "FOR_REG", "is", "negative", ",", "if", "we", "'re", "emitting", "the", "PTX", "prototype", ".", "It", "is", "zero", "if", "we", "'re", "copying", "to", "an", "argument", "register", "and", "it", "is", "greater", "than", "zero", "if", "we", "'re", "copying", "to", "a", "specific", "hard", "register", "." ]

[ "nvptx", "0", "\", \"", "\" (\"", "\".param\"", "\" %in_ar\"", "\"\\t.reg\"", "\" \"", "\"%ar\"", "\";\\n\"", "0", "\"\\tld.param\"", "\" \"", "\"%ar\"", "\", [%in_ar\"", "\"];\\n\"", "1" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_dst_builtin", "(", "tree", "exp", ",", "rtx", "target", "ATTRIBUTE_UNUSED", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "TREE_OPERAND", "(", "exp", ",", "0", ")", ",", "0", ")", ";", "tree", "arglist", "=", "TREE_OPERAND", "(", "exp", ",", "1", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg0", ",", "arg1", ",", "arg2", ";", "enum", "machine_mode", "mode0", ",", "mode1", ",", "mode2", ";", "rtx", "pat", ",", "op0", ",", "op1", ",", "op2", ";", "struct", "builtin_description", "*", "d", ";", "size_t", "i", ";", "*", "expandedp", "=", "false", ";", "d", "=", "(", "struct", "builtin_description", "*", ")", "bdesc_dst", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "bdesc_dst", ")", ";", "i", "++", ",", "d", "++", ")", "if", "(", "d", "->", "code", "==", "fcode", ")", "{", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "arg2", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "op2", "=", "expand_expr", "(", "arg2", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "mode2", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "2", "]", ".", "mode", ";", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", "||", "arg2", "==", "error_mark_node", ")", "return", "const0_rtx", ";", "*", "expandedp", "=", "true", ";", "STRIP_NOPS", "(", "arg2", ")", ";", "if", "(", "TREE_CODE", "(", "arg2", ")", "!=", "INTEGER_CST", "||", "TREE_INT_CST_LOW", "(", "arg2", ")", "&", "~", "0x3", ")", "{", "error", "(", "\"argument to %qs must be a 2-bit unsigned literal\"", ",", "d", "->", "name", ")", ";", "return", "const0_rtx", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "pat", "!=", "0", ")", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "the", "dst", "builtins", "." ]

[ "rs6000", "0", "0", "1", "0", "0", "0", "0", "0", "1", "2", "0x3", "\"argument to %qs must be a 2-bit unsigned literal\"", "0", "1", "0" ]

[]

[ "<s>", "bool", "HSAILPassConfig", "::", "addPreISel", "(", ")", "{", "addPass", "(", "createLCSSAPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "AMDGPUMCAsmInfo", "::", "shouldOmitSectionDirective", "(", "StringRef", "SectionName", ")", "const", "{", "return", "SectionName", "==", "\".hsatext\"", "||", "SectionName", "==", "\".hsadata_global_agent\"", "||", "SectionName", "==", "\".hsadata_global_program\"", "||", "SectionName", "==", "\".hsarodata_readonly_agent\"", "||", "MCAsmInfo", "::", "shouldOmitSectionDirective", "(", "SectionName", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", ".section", "directive", "should", "be", "omitted", "when", "emitting", "SectionName", "." ]

[ "AMDGPU", "AMDGPU", "\".hsatext\"", "\".hsadata_global_agent\"", "\".hsadata_global_program\"", "\".hsarodata_readonly_agent\"" ]

[]

[ "<s>", "static", "bool", "arc_enter_leave_p", "(", "unsigned", "int", "gmask", ")", "{", "int", "regno", ";", "unsigned", "int", "rmask", "=", "0", ";", "if", "(", "!", "gmask", ")", "return", "false", ";", "for", "(", "regno", "=", "ENTER_LEAVE_START_REG", ";", "regno", "<=", "ENTER_LEAVE_END_REG", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", "regno", "++", ")", "rmask", "|=", "1L", "<<", "regno", ";", "if", "(", "rmask", "^", "gmask", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "we", "have", "a", "continous", "range", "to", "be", "save/restored", "with", "the", "help", "of", "enter/leave", "instructions", ".", "A", "vaild", "register", "range", "starts", "from", "$", "r13", "and", "is", "up", "to", "(", "including", ")", "$", "r26", "." ]

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

[]

[ "<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", "mode", "==", "HImode", "||", "mode", "==", "V16BImode", "||", "mode", "==", "V8BImode", "||", "mode", "==", "V4BImode", ";", "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>", "static", "void", "avr_set_current_function", "(", "tree", "decl", ")", "{", "location_t", "loc", ";", "const", "char", "*", "isr", ";", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "loc", "=", "DECL_SOURCE_LOCATION", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_naked", "=", "avr_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_signal", "=", "avr_signal_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_interrupt", "=", "avr_interrupt_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_task", "=", "avr_OS_task_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_main", "=", "avr_OS_main_function_p", "(", "decl", ")", ";", "isr", "=", "cfun", "->", "machine", "->", "is_interrupt", "?", "\"interrupt\"", ":", "\"signal\"", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_task", "+", "cfun", "->", "machine", "->", "is_OS_main", "+", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ">", "1", ")", "error_at", "(", "loc", ",", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", "&&", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wattributes", ",", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "\"naked\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "const", "char", "*", "name", ";", "name", "=", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ":", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "cfun", "->", "machine", "->", "is_signal", "=", "0", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot have arguments\"", ",", "isr", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot return a value\"", ",", "isr", ")", ";", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__vector\"", ")", ")", "warning_at", "(", "loc", ",", "0", ",", "\"%qs appears to be a misspelled %s handler\"", ",", "name", ",", "isr", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>" ]

[ "Sanity", "cheching", "for", "above", "function", "attributes", "." ]

[ "avr", "\"interrupt\"", "\"signal\"", "1", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", "\"OS_task\"", "\"OS_main\"", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", "\"OS_task\"", "\"OS_main\"", "\"naked\"", "0", "\"%qs function cannot have arguments\"", "\"%qs function cannot return a value\"", "\"__vector\"", "0", "\"%qs appears to be a misspelled %s handler\"", "1" ]

[]

[ "<s>", "bool", "AMDGPUPropagateAttributesLate", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "return", "AMDGPUPropagateAttributes", "(", "TM", ",", "true", ")", ".", "process", "(", "M", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "mips_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2SFmode", ":", "return", "TARGET_PAIRED_SINGLE_FLOAT", ";", "case", "V2HImode", ":", "case", "V4QImode", ":", "case", "V2HQmode", ":", "case", "V2UHQmode", ":", "case", "V2HAmode", ":", "case", "V2UHAmode", ":", "case", "V4QQmode", ":", "case", "V4UQQmode", ":", "return", "TARGET_DSP", ";", "case", "V2SImode", ":", "case", "V4HImode", ":", "case", "V8QImode", ":", "return", "TARGET_LOONGSON_VECTORS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "mips" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "is64bit", ")", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes_64", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "else", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "tm", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "NVPTX", "NVPTX", "NVPTX::Int64RegsRegClass", "NVPTX::cvta_local_yes_64", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::Int32RegsRegClass", "NVPTX::cvta_local_yes", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR" ]

[]

[ "<s>", "virtual", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "return", "createVLIWMachineSched", "(", "C", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "s390_const_int_pool_entry_p", "(", "rtx", "mem", ",", "HOST_WIDE_INT", "*", "val", ")", "{", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx", "sym", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", "&&", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_LTREF", ")", "sym", "=", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ";", "else", "sym", "=", "addr", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "sym", ")", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "sym", ")", ")", "return", "false", ";", "rtx", "val_rtx", "=", "get_pool_constant", "(", "sym", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "val_rtx", ")", ")", "return", "false", ";", "if", "(", "val", "!=", "nullptr", ")", "*", "val", "=", "INTVAL", "(", "val_rtx", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "MEM", "refers", "to", "an", "integer", "constant", "in", "the", "literal", "pool", ".", "If", "VAL", "is", "not", "nullptr", ",", "then", "also", "fill", "it", "with", "the", "constant", "'s", "value", "." ]

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

[]

[ "<s>", "void", "MOSPassConfig", "::", "addOptimizedRegAlloc", "(", ")", "{", "insertPass", "(", "&", "llvm", "::", "TwoAddressInstructionPassID", ",", "&", "llvm", "::", "RegisterCoalescerID", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "int", "ix86_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "ix86_cost", "->", "scalar_stmt_cost", ";", "case", "scalar_load", ":", "return", "ix86_cost", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "ix86_cost", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "ix86_cost", "->", "vec_stmt_cost", ";", "case", "vector_load", ":", "return", "ix86_cost", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "ix86_cost", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "ix86_cost", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "ix86_cost", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "case", "unaligned_store", ":", "return", "ix86_cost", "->", "vec_unalign_load_cost", ";", "case", "cond_branch_taken", ":", "return", "ix86_cost", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "ix86_cost", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "ix86_cost", "->", "vec_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_vectorization_cost", "." ]

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

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"WebAssembly can only return up to one value\"", ")", ";", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last results\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1", "\"WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"WebAssembly hasn't implemented inalloca results\"", "\"WebAssembly hasn't implemented cons regs results\"", "\"WebAssembly hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "static", "tree", "get_prev_label", "(", "tree", "function_name", ")", "{", "tree", "branch_island", ";", "for", "(", "branch_island", "=", "branch_island_list", ";", "branch_island", ";", "branch_island", "=", "TREE_CHAIN", "(", "branch_island", ")", ")", "if", "(", "function_name", "==", "BRANCH_ISLAND_FUNCTION_NAME", "(", "branch_island", ")", ")", "return", "BRANCH_ISLAND_LABEL_NAME", "(", "branch_island", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "GET_PREV_LABEL", "gets", "the", "label", "name", "from", "the", "previous", "definition", "of", "the", "function", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "const", "bool", "isPPC64", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "const", "unsigned", "TOCReg", "=", "isPPC64", "?", "PPC", "::", "X2", ":", "PPC", "::", "R2", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "hasTOCLoReloc", "(", "MI", ")", ")", "continue", ";", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "TOCReg", ",", "false", ",", "true", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC::R2" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "SPUTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "(", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", ")", "?", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ":", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "CellSPU", "MVT::SimpleValueType", "SPU", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "const", "char", "*", "SparcTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "SPISD", "::", "CMPICC", ":", "return", "\"SPISD::CMPICC\"", ";", "case", "SPISD", "::", "CMPFCC", ":", "return", "\"SPISD::CMPFCC\"", ";", "case", "SPISD", "::", "BRICC", ":", "return", "\"SPISD::BRICC\"", ";", "case", "SPISD", "::", "BRFCC", ":", "return", "\"SPISD::BRFCC\"", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "return", "\"SPISD::SELECT_ICC\"", ";", "case", "SPISD", "::", "SELECT_FCC", ":", "return", "\"SPISD::SELECT_FCC\"", ";", "case", "SPISD", "::", "Hi", ":", "return", "\"SPISD::Hi\"", ";", "case", "SPISD", "::", "Lo", ":", "return", "\"SPISD::Lo\"", ";", "case", "SPISD", "::", "FTOI", ":", "return", "\"SPISD::FTOI\"", ";", "case", "SPISD", "::", "ITOF", ":", "return", "\"SPISD::ITOF\"", ";", "case", "SPISD", "::", "CALL", ":", "return", "\"SPISD::CALL\"", ";", "case", "SPISD", "::", "RET_FLAG", ":", "return", "\"SPISD::RET_FLAG\"", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "SPISD::CMPICC", "\"SPISD::CMPICC\"", "SPISD::CMPFCC", "\"SPISD::CMPFCC\"", "SPISD::BRICC", "\"SPISD::BRICC\"", "SPISD::BRFCC", "\"SPISD::BRFCC\"", "SPISD::SELECT_ICC", "\"SPISD::SELECT_ICC\"", "SPISD::SELECT_FCC", "\"SPISD::SELECT_FCC\"", "SPISD::Hi", "\"SPISD::Hi\"", "SPISD::Lo", "\"SPISD::Lo\"", "SPISD::FTOI", "\"SPISD::FTOI\"", "SPISD::ITOF", "\"SPISD::ITOF\"", "SPISD::CALL", "\"SPISD::CALL\"", "SPISD::RET_FLAG", "\"SPISD::RET_FLAG\"" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "loongarch_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "if", "(", "TARGET_DIRECT_EXTERN_ACCESS", ")", "return", "true", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "i386_pe_determine_dllimport_p", "(", "tree", "decl", ")", "{", "tree", "assoc", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "DECL_DLLIMPORT_P", "(", "decl", ")", ")", "return", "true", ";", "assoc", "=", "associated_type", "(", "decl", ")", ";", "if", "(", "assoc", "&&", "lookup_attribute", "(", "\"dllimport\"", ",", "TYPE_ATTRIBUTES", "(", "assoc", ")", ")", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_STATIC", "(", "decl", ")", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "!", "DECL_VIRTUAL_P", "(", "decl", ")", ")", "error", "(", "\"definition of static data member %q+D of \"", "\"dllimport%'d class\"", ",", "decl", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DECL", "should", "be", "a", "dllimport", "'d", "object", "." ]

[ "i386", "\"dllimport\"", "\"definition of static data member %q+D of \"", "\"dllimport%'d class\"" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "if", "(", "CurrentState", "==", "FunctionStart", ")", "{", "auto", "&", "TOut", "=", "reinterpret_cast", "<", "WebAssemblyTargetStreamer", "&", ">", "(", "*", "Out", ".", "getTargetStreamer", "(", ")", ")", ";", "TOut", ".", "emitLocal", "(", "SmallVector", "<", "wasm", "::", "ValType", ",", "0", ">", "(", ")", ")", ";", "}", "auto", "Align", "=", "WebAssembly", "::", "GetDefaultP2AlignAny", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Align", "!=", "-", "1U", ")", "{", "auto", "&", "Op0", "=", "Inst", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getImm", "(", ")", "==", "-", "1", ")", "Op0", ".", "setImm", "(", "Align", ")", ";", "}", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "wasm::ValType", "0", "WebAssembly::GetDefaultP2AlignAny", "1U", "0", "1", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "Register", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "getGlobalBaseRegClass", "(", "MF", ")", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "64", ")", ";", "LLT", "s64", "=", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "IsTailCall", ")", "{", "Offset", "+=", "FPDiff", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "FIReg", ",", "FI", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "return", "FIReg", ";", "}", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Register", "(", "AArch64", "::", "SP", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s64", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildGEP", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "AArch64", "0", "64", "64", "AArch64::SP" ]

[]

[ "<s>", "void", "arc_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "PREV_INSN", "(", "insn", ")", "&&", "PREV_INSN", "(", "NEXT_INSN", "(", "insn", ")", ")", "==", "insn", "&&", "arc_hazard", "(", "prev_real_insn", "(", "insn", ")", ",", "insn", ")", ")", "{", "current_output_insn", "=", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", ")", ";", "final_scan_insn", "(", "current_output_insn", ",", "asm_out_file", ",", "optimize", ",", "1", ",", "NULL", ")", ";", "current_output_insn", "=", "insn", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "prescan_initialized", ")", "{", "memset", "(", "&", "arc_ccfsm_current", ",", "0", ",", "sizeof", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "prescan_initialized", "=", "1", ";", "}", "arc_ccfsm_advance", "(", "insn", ",", "&", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "size_reason", "=", "0", ";", "}", "</s>" ]

[ "The", "state", "of", "the", "fsm", "controlling", "condition", "codes", "are", ":", "0", ":", "normal", ",", "do", "nothing", "special", "1", ":", "do", "n't", "output", "this", "insn", "2", ":", "do", "n't", "output", "this", "insn", "3", ":", "make", "insns", "conditional", "4", ":", "make", "insns", "conditional", "State", "transitions", "(", "state-", ">", "state", "by", "whom", ",", "under", "what", "condition", ")", ":", "0", "-", ">", "1", "final_prescan_insn", ",", "if", "insn", "is", "conditional", "branch", "0", "-", ">", "2", "final_prescan_insn", ",", "if", "the", "`", "target", "'", "is", "an", "unconditional", "branch", "1", "-", ">", "3", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "2", "-", ">", "4", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "3", "-", ">", "0", "(", "*", "targetm.asm_out.internal_label", ")", ",", "if", "the", "`", "target", "'", "label", "is", "reached", "(", "the", "target", "label", "has", "CODE_LABEL_NUMBER", "equal", "to", "arc_ccfsm_target_label", ")", ".", "4", "-", ">", "0", "final_prescan_insn", ",", "if", "`", "target", "'", "unconditional", "branch", "is", "reached", "If", "the", "jump", "clobbers", "the", "conditions", "then", "we", "use", "states", "2", "and", "4", ".", "A", "similar", "thing", "can", "be", "done", "with", "conditional", "return", "insns", ".", "We", "also", "handle", "separating", "branches", "from", "sets", "of", "the", "condition", "code", ".", "This", "is", "done", "here", "because", "knowledge", "of", "the", "ccfsm", "state", "is", "required", ",", "we", "may", "not", "be", "outputting", "the", "branch", "." ]

[ "arc", "\"\\n; at %04x\\n\"", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "initialize_aarch64_code_model", "(", "struct", "gcc_options", "*", "opts", ")", "{", "aarch64_cmodel", "=", "opts", "->", "x_aarch64_cmodel_var", ";", "switch", "(", "opts", "->", "x_aarch64_cmodel_var", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "opts", "->", "x_flag_pic", ")", "aarch64_cmodel", "=", "AARCH64_CMODEL_TINY_PIC", ";", "break", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "opts", "->", "x_flag_pic", ")", "{", "aarch64_cmodel", "=", "(", "flag_pic", "==", "2", "?", "AARCH64_CMODEL_SMALL_PIC", ":", "AARCH64_CMODEL_SMALL_SPIC", ")", ";", "aarch64_cmodel", "=", "AARCH64_CMODEL_SMALL_PIC", ";", "}", "break", ";", "case", "AARCH64_CMODEL_LARGE", ":", "if", "(", "opts", "->", "x_flag_pic", ")", "sorry", "(", "\"code model %qs with %<-f%s%>\"", ",", "\"large\"", ",", "opts", "->", "x_flag_pic", ">", "1", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "if", "(", "opts", "->", "x_aarch64_abi", "==", "AARCH64_ABI_ILP32", ")", "sorry", "(", "\"code model %qs not supported in ilp32 mode\"", ",", "\"large\"", ")", ";", "break", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "A", "checking", "mechanism", "for", "the", "implementation", "of", "the", "various", "code", "models", "." ]

[ "aarch64", "2", "\"code model %qs with %<-f%s%>\"", "\"large\"", "1", "\"PIC\"", "\"pic\"", "\"code model %qs not supported in ilp32 mode\"", "\"large\"" ]

[]

[ "<s>", "static", "bool", "s390_hard_regno_scratch_ok", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "!", "call_really_used_regs", "[", "regno", "]", "&&", "cfun_gpr_save_slot", "(", "regno", ")", "==", "SAVE_SLOT_NONE", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "REGNO", "can", "be", "used", "as", "a", "scratch", "register", "in", "peephole2", "." ]

[ "s390" ]

[]

[ "<s>", "void", "handle_arm_mve_types_h", "(", ")", "{", "if", "(", "handle_arm_mve_types_p", ")", "{", "error", "(", "\"duplicate definition of %qs\"", ",", "\"arm_mve_types.h\"", ")", ";", "return", ";", "}", "handle_arm_mve_types_p", "=", "true", ";", "if", "(", "!", "TARGET_HAVE_MVE", ")", "{", "error", "(", "\"this definition requires the MVE ISA extension\"", ")", ";", "return", ";", "}", "register_builtin_types", "(", ")", ";", "for", "(", "unsigned", "int", "type_i", "=", "0", ";", "type_i", "<", "NUM_VECTOR_TYPES", ";", "++", "type_i", ")", "{", "vector_type_index", "type", "=", "vector_type_index", "(", "type_i", ")", ";", "register_vector_type", "(", "type", ")", ";", "if", "(", "type_i", "!=", "VECTOR_TYPE_mve_pred16_t", ")", "register_builtin_tuple_types", "(", "type", ")", ";", "}", "}", "</s>" ]

[ "Implement", "#", "pragma", "GCC", "arm", "``", "arm_mve_types.h", "''", "." ]

[ "arm", "\"duplicate definition of %qs\"", "\"arm_mve_types.h\"", "\"this definition requires the MVE ISA extension\"", "0" ]

[]

[ "<s>", "void", "BTFTypeStruct", "::", "completeType", "(", "BTFDebug", "&", "BDebug", ")", "{", "if", "(", "IsCompleted", ")", "return", ";", "IsCompleted", "=", "true", ";", "BTFType", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "STy", "->", "getName", "(", ")", ")", ";", "const", "DINodeArray", "Elements", "=", "STy", "->", "getElements", "(", ")", ";", "for", "(", "const", "auto", "*", "Element", ":", "Elements", ")", "{", "struct", "BTF", "::", "BTFMember", "BTFMember", ";", "const", "auto", "*", "DDTy", "=", "cast", "<", "DIDerivedType", ">", "(", "Element", ")", ";", "BTFMember", ".", "NameOff", "=", "BDebug", ".", "addString", "(", "DDTy", "->", "getName", "(", ")", ")", ";", "if", "(", "HasBitField", ")", "{", "uint8_t", "BitFieldSize", "=", "DDTy", "->", "isBitField", "(", ")", "?", "DDTy", "->", "getSizeInBits", "(", ")", ":", "0", ";", "BTFMember", ".", "Offset", "=", "BitFieldSize", "<<", "24", "|", "DDTy", "->", "getOffsetInBits", "(", ")", ";", "}", "else", "{", "BTFMember", ".", "Offset", "=", "DDTy", "->", "getOffsetInBits", "(", ")", ";", "}", "const", "auto", "*", "BaseTy", "=", "DDTy", "->", "getBaseType", "(", ")", ";", "BTFMember", ".", "Type", "=", "BDebug", ".", "getTypeId", "(", "BaseTy", ")", ";", "MemberTypeNoQual", ".", "push_back", "(", "BDebug", ".", "getTypeId", "(", "stripQualifiers", "(", "BaseTy", ")", ")", ")", ";", "Members", ".", "push_back", "(", "BTFMember", ")", ";", "}", "}", "</s>" ]

[ "Complete", "BTF", "type", "generation", "after", "all", "related", "DebugInfo", "types", "have", "been", "visited", "so", "their", "BTF", "type", "id", "'s", "are", "available", "for", "cross", "referece", "." ]

[ "BPF", "BTF::BTFMember", "0", "24" ]

[]

[ "<s>", "static", "void", "arc_finalize_pic", "(", "void", ")", "{", "rtx", "pat", ";", "rtx", "baseptr_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", ")", "return", ";", "gcc_assert", "(", "flag_pic", "!=", "0", ")", ";", "pat", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_DYNAMIC\"", ")", ";", "pat", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "pat", ")", ",", "ARC_UNSPEC_GOT", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pat", ")", ";", "pat", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "baseptr_rtx", ",", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--" ]

[ "arc", "0", "0", "\"_DYNAMIC\"", "1" ]

[]

[ "<s>", "unsigned", "X86AsmBackend", "::", "getMaximumNopSize", "(", ")", "const", "{", "if", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Mode16Bit", ")", ")", "return", "4", ";", "if", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "FeatureNOPL", ")", "&&", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", ")", "return", "1", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast7ByteNOP", "]", ")", "return", "7", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast15ByteNOP", "]", ")", "return", "15", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "TuningFast11ByteNOP", "]", ")", "return", "11", ";", "return", "10", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "size", "of", "a", "nop", "in", "bytes", "on", "this", "target", "." ]

[ "X86", "X86", "X86::Mode16Bit", "4", "X86::FeatureNOPL", "X86::Mode64Bit", "1", "X86::TuningFast7ByteNOP", "7", "X86::TuningFast15ByteNOP", "15", "X86::TuningFast11ByteNOP", "11", "10" ]

[]

[ "<s>", "void", "SICMCCodeEmitter", "::", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "mn10300_adjust_sched_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "rtx", "insn_set", ";", "rtx", "dep_set", ";", "int", "timings", ";", "if", "(", "!", "TARGET_AM33", ")", "return", "1", ";", "insn_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "insn_set", ")", "return", "cost", ";", "dep_set", "=", "single_set", "(", "dep", ")", ";", "if", "(", "!", "dep_set", ")", "return", "cost", ";", "if", "(", "mn10300_tune_cpu", "==", "PROCESSOR_AM34", "&&", "set_is_load_p", "(", "dep_set", ")", "&&", "set_is_store_p", "(", "insn_set", ")", ")", "cost", "+=", "1", ";", "else", "if", "(", "mn10300_tune_cpu", "==", "PROCESSOR_AM34", "&&", "!", "set_is_store_p", "(", "insn_set", ")", "&&", "!", "JUMP_P", "(", "insn", ")", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "dep_set", ")", ")", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "insn_set", ")", ")", ")", "==", "MODE_FLOAT", ")", "cost", "+=", "1", ";", "if", "(", "!", "TARGET_AM33_2", ")", "return", "cost", ";", "if", "(", "dep_type", "==", "0", ")", "return", "cost", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "dep_set", ")", ")", ")", "!=", "MODE_FLOAT", ")", "return", "cost", ";", "if", "(", "!", "set_is_load_p", "(", "insn_set", ")", "&&", "!", "set_is_store_p", "(", "insn_set", ")", ")", "return", "cost", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SET_SRC", "(", "insn_set", ")", ")", ")", "!=", "MODE_INT", ")", "return", "cost", ";", "timings", "=", "get_attr_timings", "(", "insn", ")", ";", "return", "timings", "<", "100", "?", "(", "timings", "%", "10", ")", ":", "(", "timings", "%", "100", ")", ";", "}", "</s>" ]

[ "Update", "scheduling", "costs", "for", "situations", "that", "can", "not", "be", "described", "using", "the", "attributes", "and", "DFA", "machinery", ".", "DEP", "is", "the", "insn", "being", "scheduled", ".", "INSN", "is", "the", "previous", "insn", ".", "COST", "is", "the", "current", "cycle", "cost", "for", "DEP", "." ]

[ "mn10300", "1", "1", "1", "0", "100", "10", "100" ]

[]

[ "<s>", "const", "RegisterBank", "&", "ARMRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "ARM", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "GPRRegClassID", ":", "case", "GPRnopcRegClassID", ":", "case", "tGPR_and_tcGPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "GPRRegBankID", ")", ";", "case", "SPR_8RegClassID", ":", "case", "SPRRegClassID", ":", "case", "DPR_8RegClassID", ":", "case", "DPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "FPRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported register kind\"", ")", ";", "}", "llvm_unreachable", "(", "\"Switch should handle all register classes\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegBankID", "ARM::FPRRegBankID", "\"Unsupported register kind\"", "\"Switch should handle all register classes\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "int", "SystemZFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", "=", "(", "MFFrame", "->", "getObjectOffset", "(", "FI", ")", "+", "MFFrame", "->", "getOffsetAdjustment", "(", ")", ")", ";", "Offset", "-=", "getOffsetOfLocalArea", "(", ")", ";", "Offset", "+=", "getAllocatedStackSize", "(", "MF", ")", ";", "return", "Offset", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isTailCall", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isBranch", "(", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isGlobal", "(", ")", "||", "Op", ".", "isSymbol", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determines", "whether", "Inst", "is", "a", "tail", "call", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "MachineConstPropagator", "::", "propagate", "(", "MachineFunction", "&", "MF", ")", "{", "MachineBasicBlock", "*", "Entry", "=", "GraphTraits", "<", "MachineFunction", "*", ">", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "EntryNum", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "EntryNum", ",", "EntryNum", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", ")", "{", "CFGEdge", "Edge", "=", "FlowQ", ".", "front", "(", ")", ";", "FlowQ", ".", "pop", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picked edge \"", "<<", "printMBBReference", "(", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "first", ")", ")", "<<", "\"->\"", "<<", "printMBBReference", "(", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ")", "<<", "'\\n'", ")", ";", "if", "(", "Edge", ".", "first", "!=", "EntryNum", ")", "if", "(", "EdgeExec", ".", "count", "(", "Edge", ")", ")", "continue", ";", "EdgeExec", ".", "insert", "(", "Edge", ")", ";", "MachineBasicBlock", "*", "SB", "=", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ";", "MachineBasicBlock", "::", "const_iterator", "It", "=", "SB", "->", "begin", "(", ")", ",", "End", "=", "SB", "->", "end", "(", ")", ";", "while", "(", "It", "!=", "End", "&&", "It", "->", "isPHI", "(", ")", ")", "{", "InstrExec", ".", "insert", "(", "&", "*", "It", ")", ";", "visitPHI", "(", "*", "It", ")", ";", "++", "It", ";", "}", "while", "(", "It", "!=", "End", "&&", "It", "->", "isDebugValue", "(", ")", ")", "++", "It", ";", "assert", "(", "It", "==", "End", "||", "!", "It", "->", "isPHI", "(", ")", ")", ";", "if", "(", "It", "!=", "End", "&&", "InstrExec", ".", "count", "(", "&", "*", "It", ")", ")", "continue", ";", "while", "(", "It", "!=", "End", "&&", "!", "It", "->", "isBranch", "(", ")", ")", "{", "if", "(", "!", "It", "->", "isDebugValue", "(", ")", ")", "{", "InstrExec", ".", "insert", "(", "&", "*", "It", ")", ";", "visitNonBranch", "(", "*", "It", ")", ";", "}", "++", "It", ";", "}", "if", "(", "It", "!=", "End", ")", "{", "visitBranchesFrom", "(", "*", "It", ")", ";", "}", "else", "{", "unsigned", "SBN", "=", "SB", "->", "getNumber", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "SSB", ":", "SB", "->", "successors", "(", ")", ")", "FlowQ", ".", "push", "(", "CFGEdge", "(", "SBN", ",", "SSB", "->", "getNumber", "(", ")", ")", ")", ";", "}", "}", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ";", "Cells", ".", "print", "(", "dbgs", "(", ")", ",", "MCE", ".", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\"Dead CFG edges:\\n\"", ";", "for", "(", "const", "MachineBasicBlock", "&", "B", ":", "MF", ")", "{", "unsigned", "BN", "=", "B", ".", "getNumber", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "SB", ":", "B", ".", "successors", "(", ")", ")", "{", "unsigned", "SN", "=", "SB", "->", "getNumber", "(", ")", ";", "if", "(", "!", "EdgeExec", ".", "count", "(", "CFGEdge", "(", "BN", ",", "SN", ")", ")", ")", "dbgs", "(", ")", "<<", "\" \"", "<<", "printMBBReference", "(", "B", ")", "<<", "\" -> \"", "<<", "printMBBReference", "(", "*", "SB", ")", "<<", "'\\n'", ";", "}", "}", "}", ")", ";", "}", "</s>" ]

[ "Propgate", "synthetic", "entry", "counts", "on", "a", "callgraph", "CG", "." ]

[ "Hexagon", "\"Picked edge \"", "\"->\"", "\"Cells after propagation:\\n\"", "\"Dead CFG edges:\\n\"", "\" \"", "\" -> \"" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_minimum_incoming_stack_boundary", "(", "bool", "sibcall", ")", "{", "unsigned", "int", "incoming_stack_boundary", ";", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "incoming_stack_boundary", "=", "TARGET_64BIT", "?", "128", ":", "MIN_STACK_BOUNDARY", ";", "else", "if", "(", "ix86_user_incoming_stack_boundary", ")", "incoming_stack_boundary", "=", "ix86_user_incoming_stack_boundary", ";", "else", "if", "(", "!", "sibcall", "&&", "ix86_force_align_arg_pointer", "&&", "crtl", "->", "stack_alignment_estimated", "==", "128", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "else", "incoming_stack_boundary", "=", "ix86_default_incoming_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MIN_STACK_BOUNDARY", "&&", "lookup_attribute", "(", "\"force_align_arg_pointer\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "if", "(", "incoming_stack_boundary", "<", "crtl", "->", "parm_stack_boundary", ")", "incoming_stack_boundary", "=", "crtl", "->", "parm_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MAIN_STACK_BOUNDARY", "&&", "DECL_NAME", "(", "current_function_decl", ")", "&&", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "DECL_FILE_SCOPE_P", "(", "current_function_decl", ")", ")", "incoming_stack_boundary", "=", "MAIN_STACK_BOUNDARY", ";", "return", "incoming_stack_boundary", ";", "}", "</s>" ]

[ "Return", "minimum", "incoming", "stack", "alignment", "." ]

[ "i386", "128", "128", "\"force_align_arg_pointer\"" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X30", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Reserved", ".", "set", "(", "PPC", "::", "R29", ")", ";", "else", "Reserved", ".", "set", "(", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Reserved", ".", "set", "(", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::FP", "PPC::FP8", "PPC::BP", "PPC::BP8", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::X1", "PPC::X13", "PPC", "PPC::X31", "PPC::X30", "PPC::X2", "PPC", "PPC::R31", "PPC", "PPC::R29", "PPC::R30", "PPC", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "BitVector", "VideocoreRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "VC", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "VC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "VC", "::", "SR", ")", ";", "Reserved", ".", "set", "(", "VC", "::", "PC", ")", ";", "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", "." ]

[ "Videocore", "Videocore", "VC::SP", "VC::LR", "VC::SR", "VC::PC" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "SCS", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "ShadowCallStack", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_LR_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "SCS", "?", "CSR_AArch64_AllRegs_SCS_RegMask", ":", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "SCS", ")", "report_fatal_error", "(", "\"ShadowCallStack attribute not supported on Darwin.\"", ")", ";", "return", "getDarwinCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "SCS", "?", "CSR_AArch64_AAVPCS_SCS_RegMask", ":", "CSR_AArch64_AAVPCS_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "SCS", "?", "CSR_AArch64_SVE_AAPCS_SCS_RegMask", ":", "CSR_AArch64_SVE_AAPCS_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "SCS", "?", "CSR_AArch64_AAPCS_SwiftError_SCS_RegMask", ":", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "SwiftTail", ")", "{", "if", "(", "SCS", ")", "report_fatal_error", "(", "\"ShadowCallStack attribute not supported with swifttail\"", ")", ";", "return", "CSR_AArch64_AAPCS_SwiftTail_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "SCS", "?", "CSR_AArch64_RT_MostRegs_SCS_RegMask", ":", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "SCS", "?", "CSR_AArch64_AAPCS_SCS_RegMask", ":", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"ShadowCallStack attribute not supported on Darwin.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"ShadowCallStack attribute not supported with swifttail\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lanai load / store optimization pass\"", ";", "}", "</s>" ]

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

[ "Lanai", "\"Lanai load / store optimization pass\"" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "static_cast", "<", "uint8_t", ">", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_MBlaze", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::InputArg", "16", "MBlaze", "0", "1", "2", "0" ]

[]

[ "<s>", "BitVector", "NyuziRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Nyuzi", "::", "SP_REG", ")", ";", "Reserved", ".", "set", "(", "Nyuzi", "::", "RA_REG", ")", ";", "Reserved", ".", "set", "(", "Nyuzi", "::", "FP_REG", ")", ";", "Reserved", ".", "set", "(", "Nyuzi", "::", "GP_REG", ")", ";", "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", "." ]

[ "Nyuzi", "Nyuzi", "Nyuzi::SP_REG", "Nyuzi::RA_REG", "Nyuzi::FP_REG", "Nyuzi::GP_REG" ]

[]

[ "<s>", "void", "init_builtins", "(", ")", "{", "rvv_switcher", "rvv", ";", "if", "(", "!", "TARGET_VECTOR", ")", "return", ";", "register_builtin_types", "(", ")", ";", "if", "(", "in_lto_p", ")", "handle_pragma_vector", "(", ")", ";", "}", "</s>" ]

[ "Initialize", "all", "compiler", "built-ins", "related", "to", "RVV", "that", "should", "be", "defined", "at", "start-up", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "arc_mode_class", "array", "." ]

[ "arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "bool", "alpha_store_data_bypass_p_1", "(", "rtx_insn", "*", "out_insn", ",", "rtx", "in_set", ")", "{", "if", "(", "!", "MEM_P", "(", "SET_DEST", "(", "in_set", ")", ")", ")", "return", "false", ";", "rtx", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "out_set", ")", "return", "!", "reg_mentioned_p", "(", "SET_DEST", "(", "out_set", ")", ",", "SET_DEST", "(", "in_set", ")", ")", ";", "rtx", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "out_exp", ")", "==", "USE", "||", "GET_CODE", "(", "out_exp", ")", "==", "TRAP_IF", ")", "continue", ";", "gcc_assert", "(", "GET_CODE", "(", "out_exp", ")", "==", "SET", ")", ";", "if", "(", "reg_mentioned_p", "(", "SET_DEST", "(", "out_exp", ")", ",", "SET_DEST", "(", "in_set", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Helper", "function", "for", "alpha_store_data_bypass_p", ",", "handle", "just", "a", "single", "SET", "IN_SET", "." ]

[ "alpha", "0", "0", "0" ]

[]

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

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

[ "R600", "\"SI Lower control flow instructions\"" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "&", "ST", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

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

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

[ "Alpha", "\"Alpha Assembly Printer\"" ]

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "ST", "->", "getCPUDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "}", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "int", "mmix_local_alignment", "(", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "basic_align", ")", "{", "if", "(", "basic_align", "<", "32", ")", "return", "32", ";", "return", "basic_align", ";", "}", "</s>" ]

[ "LOCAL_ALIGNMENT", "." ]

[ "mmix", "32", "32" ]

[]

[ "<s>", "int", "riscv_const_insns", "(", "rtx", "x", ")", "{", "enum", "riscv_symbol_type", "symbol_type", ";", "rtx", "offset", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "HIGH", ":", "if", "(", "!", "riscv_symbolic_constant_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "&", "symbol_type", ")", "||", "!", "riscv_split_symbol_type", "(", "symbol_type", ")", ")", "return", "0", ";", "return", "1", ";", "case", "CONST_INT", ":", "{", "int", "cost", "=", "riscv_integer_cost", "(", "INTVAL", "(", "x", ")", ")", ";", "return", "cost", "<", "4", "?", "cost", ":", "0", ";", "}", "case", "CONST_DOUBLE", ":", "case", "CONST_VECTOR", ":", "return", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "?", "1", ":", "0", ";", "case", "CONST", ":", "if", "(", "riscv_symbolic_constant_p", "(", "x", ",", "&", "symbol_type", ")", ")", "return", "riscv_symbol_insns", "(", "symbol_type", ")", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "int", "n", "=", "riscv_const_insns", "(", "x", ")", ";", "if", "(", "n", "!=", "0", ")", "return", "n", "+", "riscv_integer_cost", "(", "INTVAL", "(", "offset", ")", ")", ";", "}", "return", "0", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "riscv_symbol_insns", "(", "riscv_classify_symbol", "(", "x", ")", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "constant", "X", ".", "Return", "0", "if", "X", "is", "n't", "a", "valid", "constant", "." ]

[ "riscv", "0", "0", "1", "4", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "Instruction", "*", "RISCVTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "Inst", ")", "&&", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "Builder", ".", "CreateFence", "(", "Ord", ")", ";", "if", "(", "isa", "<", "StoreInst", ">", "(", "Inst", ")", "&&", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "Release", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "Hexagon", "\"Hexagon RDF optimizations\"" ]

[]

[ "<s>", "virtual", "bool", "check", "(", "function_checker", "&", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Perform", "semantic", "checks", "on", "the", "call", ".", "Return", "true", "if", "the", "call", "is", "valid", ",", "otherwise", "report", "a", "suitable", "error", "." ]

[ "aarch64" ]

[]

[ "<s>", "SUnit", "*", "GCNMaxOccupancySchedStrategy", "::", "pickNodeBidirectional", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "false", ";", "return", "SU", ";", "}", "if", "(", "SUnit", "*", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "true", ";", "return", "SU", ";", "}", "CandPolicy", "BotPolicy", ";", "setPolicy", "(", "BotPolicy", ",", "false", ",", "Bot", ",", "&", "Top", ")", ";", "CandPolicy", "TopPolicy", ";", "setPolicy", "(", "TopPolicy", ",", "false", ",", "Top", ",", "&", "Bot", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking from Bot:\\n\"", ")", ";", "if", "(", "!", "BotCand", ".", "isValid", "(", ")", "||", "BotCand", ".", "SU", "->", "isScheduled", "||", "BotCand", ".", "Policy", "!=", "BotPolicy", ")", "{", "BotCand", ".", "reset", "(", "CandPolicy", "(", ")", ")", ";", "pickNodeFromQueue", "(", "Bot", ",", "BotPolicy", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "traceCandidate", "(", "BotCand", ")", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking from Top:\\n\"", ")", ";", "if", "(", "!", "TopCand", ".", "isValid", "(", ")", "||", "TopCand", ".", "SU", "->", "isScheduled", "||", "TopCand", ".", "Policy", "!=", "TopPolicy", ")", "{", "TopCand", ".", "reset", "(", "CandPolicy", "(", ")", ")", ";", "pickNodeFromQueue", "(", "Top", ",", "TopPolicy", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "traceCandidate", "(", "TopCand", ")", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Top Cand: \"", ";", "traceCandidate", "(", "TopCand", ")", ";", "dbgs", "(", ")", "<<", "\"Bot Cand: \"", ";", "traceCandidate", "(", "BotCand", ")", ";", ")", ";", "SchedCandidate", "Cand", ";", "if", "(", "TopCand", ".", "Reason", "==", "BotCand", ".", "Reason", ")", "{", "Cand", "=", "BotCand", ";", "GenericSchedulerBase", "::", "CandReason", "TopReason", "=", "TopCand", ".", "Reason", ";", "TopCand", ".", "Reason", "=", "NoCand", ";", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TopCand", ",", "nullptr", ")", ";", "if", "(", "TopCand", ".", "Reason", "!=", "NoCand", ")", "{", "Cand", ".", "setBest", "(", "TopCand", ")", ";", "}", "else", "{", "TopCand", ".", "Reason", "=", "TopReason", ";", "}", "}", "else", "{", "if", "(", "TopCand", ".", "Reason", "==", "RegExcess", "&&", "TopCand", ".", "RPDelta", ".", "Excess", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "if", "(", "BotCand", ".", "Reason", "==", "RegExcess", "&&", "BotCand", ".", "RPDelta", ".", "Excess", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "BotCand", ";", "}", "else", "if", "(", "TopCand", ".", "Reason", "==", "RegCritical", "&&", "TopCand", ".", "RPDelta", ".", "CriticalMax", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "if", "(", "BotCand", ".", "Reason", "==", "RegCritical", "&&", "BotCand", ".", "RPDelta", ".", "CriticalMax", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "BotCand", ";", "}", "else", "{", "if", "(", "BotCand", ".", "Reason", ">", "TopCand", ".", "Reason", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "{", "Cand", "=", "BotCand", ";", "}", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking: \"", ";", "traceCandidate", "(", "Cand", ")", ";", ")", ";", "IsTopNode", "=", "Cand", ".", "AtTop", ";", "return", "Cand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "node", "from", "either", "the", "top", "or", "bottom", "queue", "." ]

[ "AMDGPU", "\"Picking from Bot:\\n\"", "\"failed to find the first candidate\"", "\"Picking from Top:\\n\"", "\"failed to find the first candidate\"", "\"Top Cand: \"", "\"Bot Cand: \"", "0", "0", "0", "0", "\"Picking: \"" ]

[]

[ "<s>", "void", "mips_expand_vec_unpack", "(", "rtx", "operands", "[", "2", "]", ",", "bool", "unsigned_p", ",", "bool", "high_p", ")", "{", "machine_mode", "imode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "(", "*", "unpack", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "cmpgt", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "tmp", ",", "dest", ",", "zero", ";", "switch", "(", "imode", ")", "{", "case", "V8QImode", ":", "if", "(", "high_p", ")", "unpack", "=", "gen_loongson_punpckhbh", ";", "else", "unpack", "=", "gen_loongson_punpcklbh", ";", "cmpgt", "=", "gen_loongson_pcmpgtb", ";", "break", ";", "case", "V4HImode", ":", "if", "(", "high_p", ")", "unpack", "=", "gen_loongson_punpckhhw", ";", "else", "unpack", "=", "gen_loongson_punpcklhw", ";", "cmpgt", "=", "gen_loongson_pcmpgth", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "zero", "=", "force_reg", "(", "imode", ",", "CONST0_RTX", "(", "imode", ")", ")", ";", "if", "(", "unsigned_p", ")", "tmp", "=", "zero", ";", "else", "{", "tmp", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "cmpgt", "(", "tmp", ",", "zero", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "dest", "=", "gen_reg_rtx", "(", "imode", ")", ";", "emit_insn", "(", "unpack", "(", "dest", ",", "operands", "[", "1", "]", ",", "tmp", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "dest", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "integral", "vector", "unpack", "operation", "." ]

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

[]

[ "<s>", "int", "SystemZTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ")", "{", "unsigned", "ScalarBits", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "assert", "(", "ST", "->", "hasVector", "(", ")", "&&", "\"getArithmeticInstrCost() called with vector type.\"", ")", ";", "unsigned", "VF", "=", "Ty", "->", "getVectorNumElements", "(", ")", ";", "unsigned", "NumVectors", "=", "getNumberOfParts", "(", "Ty", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "Shl", "||", "Opcode", "==", "Instruction", "::", "LShr", "||", "Opcode", "==", "Instruction", "::", "AShr", ")", "{", "return", "NumVectors", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "FAdd", "||", "Opcode", "==", "Instruction", "::", "FSub", "||", "Opcode", "==", "Instruction", "::", "FMul", "||", "Opcode", "==", "Instruction", "::", "FDiv", ")", "{", "switch", "(", "ScalarBits", ")", "{", "case", "32", ":", "{", "unsigned", "ScalarCost", "=", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", "->", "getScalarType", "(", ")", ")", ";", "unsigned", "Cost", "=", "(", "VF", "*", "ScalarCost", ")", "+", "getScalarizationOverhead", "(", "Ty", ",", "Args", ")", ";", "if", "(", "VF", "==", "2", ")", "Cost", "*=", "2", ";", "return", "Cost", ";", "}", "case", "64", ":", "case", "128", ":", "return", "NumVectors", ";", "default", ":", "break", ";", "}", "}", "if", "(", "Opcode", "==", "Instruction", "::", "FRem", ")", "{", "unsigned", "Cost", "=", "(", "VF", "*", "LIBCALL_COST", ")", "+", "getScalarizationOverhead", "(", "Ty", ",", "Args", ")", ";", "if", "(", "VF", "==", "2", "&&", "ScalarBits", "==", "32", ")", "Cost", "*=", "2", ";", "return", "Cost", ";", "}", "}", "else", "{", "if", "(", "Opcode", "==", "Instruction", "::", "FAdd", "||", "Opcode", "==", "Instruction", "::", "FSub", "||", "Opcode", "==", "Instruction", "::", "FMul", "||", "Opcode", "==", "Instruction", "::", "FDiv", ")", "return", "1", ";", "if", "(", "Opcode", "==", "Instruction", "::", "FRem", ")", "return", "LIBCALL_COST", ";", "if", "(", "Opcode", "==", "Instruction", "::", "LShr", "||", "Opcode", "==", "Instruction", "::", "AShr", ")", "return", "(", "ScalarBits", ">=", "32", "?", "1", ":", "2", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "Or", ")", "return", "1", ";", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "ScalarBits", "==", "1", ")", "return", "7", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", ")", ")", "return", "(", "ScalarBits", "<", "32", "?", "4", ":", "(", "ScalarBits", "==", "32", "?", "2", ":", "1", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "return", "(", "ScalarBits", "<", "32", "?", "4", ":", "2", ")", ";", "}", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"getArithmeticInstrCost() called with vector type.\"", "32", "2", "2", "64", "128", "2", "32", "2", "1", "32", "1", "2", "1", "1", "7", "32", "4", "32", "2", "1", "32", "4", "2" ]

[]

[ "<s>", "void", "MOSTargetStreamer", "::", "finish", "(", ")", "{", "MCStreamer", "&", "OS", "=", "getStreamer", "(", ")", ";", "MCContext", "&", "Context", "=", "OS", ".", "getContext", "(", ")", ";", "if", "(", "hasBSS", "(", ")", ")", "stronglyReference", "(", "\"__do_zero_bss\"", ",", "\"Declaring this symbol tells the CRT that there is \"", "\"something in BSS, so it may need to be zeroed.\"", ")", ";", "if", "(", "hasData", "(", ")", ")", "stronglyReference", "(", "\"__do_copy_data\"", ",", "\"Declaring this symbol tells the CRT that there is something in .data, \"", "\"so it may need to be copied from LMA to VMA.\"", ")", ";", "if", "(", "hasInitArray", "(", ")", ")", "stronglyReference", "(", "\"__do_init_array\"", ",", "\"Declaring this symbol tells the CRT that there are \"", "\"initialization routines to be run in .init_array\"", ")", ";", "if", "(", "hasFiniArray", "(", ")", ")", "stronglyReference", "(", "\"__do_fini_array\"", ",", "\"Declaring this symbol tells the CRT that there are \"", "\"finalization routines to be run in .fini_array\"", ")", ";", "for", "(", "const", "auto", "&", "TableEntry", ":", "Context", ".", "getSymbols", "(", ")", ")", "{", "if", "(", "TableEntry", ".", "getKey", "(", ")", "!=", "\"__rc0\"", "&&", "TableEntry", ".", "getKey", "(", ")", "!=", "\"__rc1\"", ")", "continue", ";", "stronglyReference", "(", "\"__do_init_stack\"", ",", "\"Declaring this symbol tells the CRT that the stack \"", "\"pointer needs to be initialized.\"", ")", ";", "}", "}", "</s>" ]

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

[ "MOS", "MOS", "\"__do_zero_bss\"", "\"Declaring this symbol tells the CRT that there is \"", "\"something in BSS, so it may need to be zeroed.\"", "\"__do_copy_data\"", "\"Declaring this symbol tells the CRT that there is something in .data, \"", "\"so it may need to be copied from LMA to VMA.\"", "\"__do_init_array\"", "\"Declaring this symbol tells the CRT that there are \"", "\"initialization routines to be run in .init_array\"", "\"__do_fini_array\"", "\"Declaring this symbol tells the CRT that there are \"", "\"finalization routines to be run in .fini_array\"", "\"__rc0\"", "\"__rc1\"", "\"__do_init_stack\"", "\"Declaring this symbol tells the CRT that the stack \"", "\"pointer needs to be initialized.\"" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "{", "if", "(", "Imm", "==", "255", "||", "Imm", "==", "65535", ")", "return", "0", ";", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ")", ")", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "Imm", ".", "isAllOnesValue", "(", ")", ")", "return", "0", ";", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "0", "255", "65535", "0", "32", "1", "12", "0", "1", "8", "0", "0" ]

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "{", "Reserved", ".", "set", "(", "SP", "::", "G2", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G4", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G7", ")", ";", "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", "." ]

[ "Sparc", "Sparc", "SP::G1", "SP::G2", "SP::G3", "SP::G4", "SP::G5", "SP::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G6", "SP::G7" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "M680x0RegisterInfo", "::", "getRegsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "&", "M680x0", "::", "XR32_TCRegClass", ";", "}", "</s>" ]

[ "Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "." ]

[ "M680x0", "M680x0", "M680x0::XR32_TCRegClass" ]

[]

[ "<s>", "rtx", "aarch64_simd_expand_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", "==", "AARCH64_SIMD_BUILTIN_LANE_CHECK", ")", "{", "rtx", "totalsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "rtx", "elementsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "totalsize", ")", "&&", "CONST_INT_P", "(", "elementsize", ")", "&&", "UINTVAL", "(", "elementsize", ")", "!=", "0", "&&", "UINTVAL", "(", "totalsize", ")", "!=", "0", ")", "{", "rtx", "lane_idx", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "lane_idx", ")", ")", "aarch64_simd_lane_bounds", "(", "lane_idx", ",", "0", ",", "UINTVAL", "(", "totalsize", ")", "/", "UINTVAL", "(", "elementsize", ")", ",", "exp", ")", ";", "else", "error", "(", "\"%Klane index must be a constant immediate\"", ",", "exp", ")", ";", "}", "else", "error", "(", "\"%Ktotal size and element size must be a non-zero constant immediate\"", ",", "exp", ")", ";", "return", "const0_rtx", ";", "}", "aarch64_simd_builtin_datum", "*", "d", "=", "&", "aarch64_simd_builtin_data", "[", "fcode", "-", "AARCH64_SIMD_PATTERN_START", "]", ";", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_simd_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "SIMD_ARG_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "SIMD_ARG_CONSTANT", ":", "SIMD_ARG_COPY_TO_REG", ";", "}", "else", "args", "[", "k", "]", "=", "SIMD_ARG_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "SIMD_ARG_STOP", ";", "return", "aarch64_simd_expand_args", "(", "target", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Expand", "an", "AArch64", "AdvSIMD", "builtin", "(", "intrinsic", ")", "." ]

[ "aarch64", "0", "1", "0", "0", "2", "0", "\"%Klane index must be a constant immediate\"", "\"%Ktotal size and element size must be a non-zero constant immediate\"", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "DecodeStatus", "CSKYDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "MCDisassembler", "::", "Fail", ";", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "(", "Insn", ">>", "14", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "(", "Insn", "<<", "16", ")", "|", "support", "::", "endian", "::", "read16le", "(", "&", "Bytes", "[", "2", "]", ")", ";", "if", "(", "decodeFPUV3Instruction", "(", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ")", "Result", "=", "MCDisassembler", "::", "Success", ";", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying CSKY 32-bit table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying CSKY 16-bit table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "handleCROperand", "(", "MI", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "support::endian", "14", "0x3", "4", "0", "16", "support::endian", "2", "\"Trying CSKY 32-bit table :\\n\"", "4", "2", "0", "\"Trying CSKY 16-bit table :\\n\"", "2" ]

[]

[ "<s>", "bool", "check_if_valid_sleep_operand", "(", "rtx", "*", "operands", ",", "int", "opno", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "opno", "]", ")", ")", "{", "case", "CONST", ":", "case", "CONST_INT", ":", "if", "(", "UNSIGNED_INT6", "(", "INTVAL", "(", "operands", "[", "opno", "]", ")", ")", ")", "return", "true", ";", "default", ":", "fatal_error", "(", "input_location", ",", "\"operand for sleep instruction must be an unsigned 6 bit compile-time constant\"", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "that", "after", "all", "the", "constant", "folding", ",", "whether", "the", "operand", "to", "__builtin_arc_sleep", "is", "an", "unsigned", "int", "of", "6", "bits", ".", "If", "not", ",", "flag", "an", "error", "." ]

[ "arc", "\"operand for sleep instruction must be an unsigned 6 bit compile-time constant\"" ]

[]

[ "<s>", "void", "AMDGPUAsmParser", "::", "peekTokens", "(", "MutableArrayRef", "<", "AsmToken", ">", "Tokens", ")", "{", "auto", "TokCount", "=", "getLexer", "(", ")", ".", "peekTokens", "(", "Tokens", ")", ";", "for", "(", "auto", "Idx", "=", "TokCount", ";", "Idx", "<", "Tokens", ".", "size", "(", ")", ";", "++", "Idx", ")", "Tokens", "[", "Idx", "]", "=", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ")", ";", "}", "</s>" ]

[ "Look", "ahead", "an", "arbitrary", "number", "of", "tokens", "." ]

[ "AMDGPU", "AMDGPU", "\"\"" ]

[]

[ "<s>", "bool", "M88kPassConfig", "::", "addRegBankSelect", "(", ")", "{", "addPass", "(", "new", "RegBankSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "register", "bank", "selector", "pass", ",", "which", "assigns", "register", "banks", "to", "virtual", "registers", "without", "a", "register", "class", "or", "register", "banks", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addFastRegAlloc", "(", ")", "{", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "SIPreAllocateWWMRegsID", ",", "false", ")", ";", "TargetPassConfig", "::", "addFastRegAlloc", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "struct", "machine_function", "*", "cris_init_machine_status", "(", "void", ")", "{", "return", "ggc_alloc_cleared", "(", "sizeof", "(", "struct", "machine_function", ")", ")", ";", "}", "</s>" ]

[ "Zero", "initialization", "is", "OK", "for", "all", "current", "fields", "." ]

[ "cris" ]

[]

[ "<s>", "static", "void", "recombine_stvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "MEM_P", "(", "SET_DEST", "(", "body", ")", ")", "&&", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "||", "pattern_is_rotate64", "(", "body", ")", ")", ")", ";", "rtx", "mem", "=", "SET_DEST", "(", "body", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "auto_vec", "<", "rtx_insn", "*", ">", "and_insns", ";", "auto_vec", "<", "rtx", ">", "and_ops", ";", "bool", "is_any_def_and", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ",", "&", "and_insns", ",", "&", "and_ops", ")", ";", "if", "(", "is_any_def_and", ")", "{", "gcc_assert", "(", "and_insns", ".", "length", "(", ")", "==", "and_ops", ".", "length", "(", ")", ")", ";", "rtx", "src_reg", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "df_ref", "src_use", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_USE", "(", "src_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "src_use", ")", ",", "src_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "src_use", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "rtx", "new_reg", "=", "0", ";", "rtx", "and_mask", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "and_insns", ".", "length", "(", ")", ";", "i", "++", ")", "{", "rtx_insn", "*", "and_insn", "=", "and_insns", "[", "i", "]", ";", "rtx", "and_op", "=", "and_ops", "[", "i", "]", ";", "rtx", "and_base", "=", "XEXP", "(", "and_op", ",", "0", ")", ";", "if", "(", "!", "new_reg", ")", "{", "new_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "and_base", ")", ")", ";", "and_mask", "=", "XEXP", "(", "and_op", ",", "1", ")", ";", "}", "rtx", "copy", "=", "gen_rtx_SET", "(", "new_reg", ",", "and_base", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_after", "(", "copy", ",", "and_insn", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "and_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "}", "XEXP", "(", "mem", ",", "0", ")", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "new_reg", ")", ",", "new_reg", ",", "and_mask", ")", ";", "SET_SRC", "(", "body", ")", "=", "src_reg", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"stvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "store", "for", "an", "stvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "1", "0", "1", "\"stvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "bool", "RISCVDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_A", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "DecodeStatus", "MipsDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "IsMicroMips", ")", "{", "Result", "=", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsBigEndian", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying MicroMips16 table (16-bit instructions):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMicroMips16", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsBigEndian", ",", "true", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying MicroMips32 table (32-bit instructions):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMicroMips32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsBigEndian", ",", "false", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "hasCOP3", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying COP3_ table (32-bit opcodes):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableCOP3_32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "if", "(", "hasMips32r6", "(", ")", "&&", "isGP64", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying Mips32r6_64r6 (GPR64) table (32-bit opcodes):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32r6_64r6_GP6432", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "if", "(", "hasMips32r6", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying Mips32r6_64r6 table (32-bit opcodes):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32r6_64r632", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "if", "(", "isGP64", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying Mips64 (GPR64) table (32-bit opcodes):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMips6432", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying Mips table (32-bit opcodes):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableMips32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"Trying MicroMips16 table (16-bit instructions):\\n\"", "Mips", "2", "\"Trying MicroMips32 table (32-bit instructions):\\n\"", "Mips", "4", "\"Trying COP3_ table (32-bit opcodes):\\n\"", "4", "Mips", "\"Trying Mips32r6_64r6 (GPR64) table (32-bit opcodes):\\n\"", "Mips", "4", "Mips", "\"Trying Mips32r6_64r6 table (32-bit opcodes):\\n\"", "Mips", "4", "\"Trying Mips64 (GPR64) table (32-bit opcodes):\\n\"", "Mips", "4", "\"Trying Mips table (32-bit opcodes):\\n\"", "Mips", "4" ]

[]

[ "<s>", "const", "char", "*", "m68k_output_scc", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"seq %0\"", ";", "case", "NE", ":", "return", "\"sne %0\"", ";", "case", "GT", ":", "return", "\"sgt %0\"", ";", "case", "GTU", ":", "return", "\"shi %0\"", ";", "case", "LT", ":", "return", "\"slt %0\"", ";", "case", "LTU", ":", "return", "\"scs %0\"", ";", "case", "GE", ":", "return", "\"sge %0\"", ";", "case", "GEU", ":", "return", "\"scc %0\"", ";", "case", "LE", ":", "return", "\"sle %0\"", ";", "case", "LEU", ":", "return", "\"sls %0\"", ";", "case", "PLUS", ":", "return", "\"spl %0\"", ";", "case", "MINUS", ":", "return", "\"smi %0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "output", "template", "for", "a", "scc", "instruction", "with", "CODE", "." ]

[ "m68k", "\"seq %0\"", "\"sne %0\"", "\"sgt %0\"", "\"shi %0\"", "\"slt %0\"", "\"scs %0\"", "\"sge %0\"", "\"scc %0\"", "\"sle %0\"", "\"sls %0\"", "\"spl %0\"", "\"smi %0\"" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "ix86_simd_clone_compute_vecsize_and_simdlen", "(", "struct", "cgraph_node", "*", "node", ",", "struct", "cgraph_simd_clone", "*", "clonei", ",", "tree", "base_type", ",", "int", "num", ")", "{", "int", "ret", "=", "1", ";", "if", "(", "clonei", "->", "simdlen", "&&", "(", "clonei", "->", "simdlen", "<", "2", "||", "clonei", "->", "simdlen", ">", "16", "||", "(", "clonei", "->", "simdlen", "&", "(", "clonei", "->", "simdlen", "-", "1", ")", ")", "!=", "0", ")", ")", "{", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"unsupported simdlen %d\"", ",", "clonei", "->", "simdlen", ")", ";", "return", "0", ";", "}", "tree", "ret_type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", "->", "decl", ")", ")", ";", "if", "(", "TREE_CODE", "(", "ret_type", ")", "!=", "VOID_TYPE", ")", "switch", "(", "TYPE_MODE", "(", "ret_type", ")", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "SFmode", ":", "case", "DFmode", ":", "break", ";", "default", ":", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"unsupported return type %qT for simd\\n\"", ",", "ret_type", ")", ";", "return", "0", ";", "}", "tree", "t", ";", "int", "i", ";", "for", "(", "t", "=", "DECL_ARGUMENTS", "(", "node", "->", "decl", ")", ",", "i", "=", "0", ";", "t", ";", "t", "=", "DECL_CHAIN", "(", "t", ")", ",", "i", "++", ")", "switch", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "t", ")", ")", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "SFmode", ":", "case", "DFmode", ":", "break", ";", "default", ":", "warning_at", "(", "DECL_SOURCE_LOCATION", "(", "node", "->", "decl", ")", ",", "0", ",", "\"unsupported argument type %qT for simd\\n\"", ",", "TREE_TYPE", "(", "t", ")", ")", ";", "return", "0", ";", "}", "if", "(", "clonei", "->", "cilk_elemental", ")", "{", "clonei", "->", "vecsize_mangle", "=", "'b'", ";", "}", "else", "if", "(", "!", "TREE_PUBLIC", "(", "node", "->", "decl", ")", ")", "{", "if", "(", "TARGET_AVX2", ")", "clonei", "->", "vecsize_mangle", "=", "'d'", ";", "else", "if", "(", "TARGET_AVX", ")", "clonei", "->", "vecsize_mangle", "=", "'c'", ";", "else", "clonei", "->", "vecsize_mangle", "=", "'b'", ";", "ret", "=", "1", ";", "}", "else", "{", "clonei", "->", "vecsize_mangle", "=", "\"bcd\"", "[", "num", "]", ";", "ret", "=", "3", ";", "}", "switch", "(", "clonei", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "clonei", "->", "vecsize_int", "=", "128", ";", "clonei", "->", "vecsize_float", "=", "128", ";", "break", ";", "case", "'c'", ":", "clonei", "->", "vecsize_int", "=", "128", ";", "clonei", "->", "vecsize_float", "=", "256", ";", "break", ";", "case", "'d'", ":", "clonei", "->", "vecsize_int", "=", "256", ";", "clonei", "->", "vecsize_float", "=", "256", ";", "break", ";", "}", "if", "(", "clonei", "->", "simdlen", "==", "0", ")", "{", "if", "(", "SCALAR_INT_MODE_P", "(", "TYPE_MODE", "(", "base_type", ")", ")", ")", "clonei", "->", "simdlen", "=", "clonei", "->", "vecsize_int", ";", "else", "clonei", "->", "simdlen", "=", "clonei", "->", "vecsize_float", ";", "clonei", "->", "simdlen", "/=", "GET_MODE_BITSIZE", "(", "TYPE_MODE", "(", "base_type", ")", ")", ";", "if", "(", "clonei", "->", "simdlen", ">", "16", ")", "clonei", "->", "simdlen", "=", "16", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Set", "CLONEI-", ">", "vecsize_mangle", ",", "CLONEI-", ">", "vecsize_int", ",", "CLONEI-", ">", "vecsize_float", "and", "if", "CLONEI-", ">", "simdlen", "is", "0", ",", "also", "CLONEI-", ">", "simdlen", ".", "Return", "0", "if", "SIMD", "clones", "should", "n't", "be", "emitted", ",", "or", "number", "of", "vecsize_mangle", "variants", "that", "should", "be", "emitted", "." ]

[ "i386", "1", "2", "16", "1", "0", "0", "\"unsupported simdlen %d\"", "0", "0", "\"unsupported return type %qT for simd\\n\"", "0", "0", "0", "\"unsupported argument type %qT for simd\\n\"", "0", "1", "\"bcd\"", "3", "128", "128", "128", "256", "256", "256", "0", "16", "16" ]

[]

[ "<s>", "static", "rtx", "rs6000_parallel_return", "(", "machine_mode", "mode", ",", "int", "n_elts", ",", "machine_mode", "elt_mode", ",", "unsigned", "int", "regno", ",", "unsigned", "int", "reg_stride", ")", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "n_elts", ")", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "elt_mode", ",", "regno", ")", ";", "rtx", "off", "=", "GEN_INT", "(", "i", "*", "GET_MODE_SIZE", "(", "elt_mode", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "off", ")", ";", "regno", "+=", "reg_stride", ";", "}", "return", "par", ";", "}", "</s>" ]

[ "Return", "an", "rtx", "describing", "a", "return", "value", "of", "MODE", "as", "a", "PARALLEL", "in", "N_ELTS", "registers", ",", "each", "of", "mode", "ELT_MODE", ",", "starting", "at", "REGNO", ",", "stride", "REG_STRIDE", "." ]

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

[]

[ "<s>", "static", "bool", "msp430_use_32bit_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "if", "(", "msp430_hwmult_type", "==", "MSP430_HWMULT_LARGE", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "MSP430_HWMULT_AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "msp430_extract_mcu_data", "(", "target_mcu", ")", ";", "if", "(", "extracted_mcu_data", ".", "name", "!=", "NULL", ")", "return", "cached_result", "=", "extracted_mcu_data", ".", "hwmpy", "==", "4", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "has", "a", "second", "generation", "32-bit", "hardware", "multiplier", "." ]

[ "msp430", "4" ]

[]

[ "<s>", "static", "int", "arc_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "(", "mode", "==", "BLKmode", "?", "int_size_in_bytes", "(", "type", ")", ":", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "cum", ";", "int", "ret", ";", "arg_num", "=", "ROUND_ADVANCE_CUM", "(", "arg_num", ",", "mode", ",", "type", ")", ";", "ret", "=", "GPR_REST_ARG_REGS", "(", "arg_num", ")", ";", "ret", "=", "(", "ret", ">=", "words", "?", "0", ":", "ret", "*", "UNITS_PER_WORD", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", "." ]

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "AMDGPUGenRegisterInfo", "::", "getRegPressureLimit", "(", "RC", ",", "MF", ")", ";", "case", "AMDGPU", "::", "VGPR_32RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ")", ";", "case", "AMDGPU", "::", "SGPR_32RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU::VGPR_32RegClassID", "AMDGPU::SGPR_32RegClassID" ]

[]

[ "<s>", "static", "bool", "loongarch_tls_symbol_p", "(", "rtx", "x", ")", "{", "return", "SYMBOL_REF_P", "(", "x", ")", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "thread-local", "symbol", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "static", "int", "write_one_arg", "(", "std", "::", "stringstream", "&", "s", ",", "tree", "type", ",", "int", "i", ",", "machine_mode", "mode", ",", "bool", "no_arg_types", ")", "{", "if", "(", "!", "PASS_IN_REG_P", "(", "mode", ",", "type", ")", ")", "mode", "=", "Pmode", ";", "int", "count", "=", "maybe_split_mode", "(", "&", "mode", ")", ";", "if", "(", "count", "==", "2", ")", "{", "write_one_arg", "(", "s", ",", "NULL_TREE", ",", "i", ",", "mode", ",", "false", ")", ";", "write_one_arg", "(", "s", ",", "NULL_TREE", ",", "i", "+", "1", ",", "mode", ",", "false", ")", ";", "return", "i", "+", "1", ";", "}", "if", "(", "no_arg_types", "&&", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "mode", "=", "DFmode", ";", "mode", "=", "arg_promotion", "(", "mode", ")", ";", "}", "if", "(", "i", ">", "0", ")", "s", "<<", "\", \"", ";", "s", "<<", "\".param\"", "<<", "nvptx_ptx_type_from_mode", "(", "mode", ",", "false", ")", "<<", "\" %in_ar\"", "<<", "(", "i", "+", "1", ")", "<<", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", "?", "\"[1]\"", ":", "\"\"", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "s", "<<", "\"[\"", "<<", "int_size_in_bytes", "(", "type", ")", "<<", "\"]\"", ";", "return", "i", ";", "}", "</s>" ]

[ "Write", "the", "declaration", "of", "a", "function", "arg", "of", "TYPE", "to", "S.", "I", "is", "the", "index", "of", "the", "argument", ",", "MODE", "its", "mode", ".", "NO_ARG_TYPES", "is", "true", "if", "this", "is", "for", "a", "decl", "with", "zero", "TYPE_ARG_TYPES", ",", "i.e", ".", "an", "old-style", "C", "decl", "." ]

[ "nvptx", "2", "1", "1", "0", "\", \"", "\".param\"", "\" %in_ar\"", "1", "\"[1]\"", "\"\"", "\"[\"", "\"]\"" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "if", "(", "Value", ")", "{", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Ctx", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "\"Unsupported relocation: try to compile with -O2 or above, \"", "\"or check your static variable usage\"", ")", ";", "}", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ",", "Value", ",", "Endian", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "Value", "=", "(", "uint32_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "Endian", "==", "support", "::", "little", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x10", ";", "support", "::", "endian", "::", "write32le", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "1", "]", "=", "0x1", ";", "support", "::", "endian", "::", "write32be", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "4", "]", ",", "Value", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", ",", "Value", ",", "Endian", ")", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "\"Unsupported relocation: try to compile with -O2 or above, \"", "\"or check your static variable usage\"", "support::endian", "support::endian", "8", "8", "support::little", "1", "0x10", "support::endian", "4", "1", "0x1", "support::endian", "4", "8", "8", "support::endian", "2" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "!", "Res", ".", "getNode", "(", ")", ")", "return", ";", "if", "(", "N", "->", "getNumValues", "(", ")", "==", "1", ")", "{", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "assert", "(", "(", "N", "->", "getNumValues", "(", ")", "==", "Res", "->", "getNumValues", "(", ")", ")", "&&", "\"Lowering returned the wrong number of results!\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "N", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "X86", "X86", "0", "1", "\"Lowering returned the wrong number of results!\"", "0" ]

[]

[ "<s>", "static", "bool", "isInstr", "(", "IndexType", "X", ")", "{", "return", "X", ".", "Index", ">=", "First", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "SUnit", "refers", "to", "a", "machine", "instruction", "as", "opposed", "to", "an", "SDNode", "." ]

[ "Hexagon" ]

[]

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

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

[ "AGC", "AGC", "\"No relaxation implemented\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", "Ty", ")", "const", "{", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "if", "(", "!", "X86", "::", "isOffsetSuitableForCodeModel", "(", "AM", ".", "BaseOffs", ",", "M", ",", "AM", ".", "BaseGV", "!=", "NULL", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "unsigned", "GVFlags", "=", "Subtarget", "->", "ClassifyGlobalReference", "(", "AM", ".", "BaseGV", ",", "getTargetMachine", "(", ")", ")", ";", "if", "(", "isGlobalStubReference", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "isGlobalRelativeToPICBase", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "Scale", ">", "1", ")", ")", "return", "false", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "case", "3", ":", "case", "5", ":", "case", "9", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::isOffsetSuitableForCodeModel", "1", "0", "1", "2", "4", "8", "3", "5", "9" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "case", "RISCV", "::", "PseudoLA", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "RISCV::PseudoLA", "8", "RISCV", "0" ]

[]

[ "<s>", "bool", "IA64TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createIA64DAGToDAGInstructionSelector", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "IA64", "IA64", "IA64" ]

[]