Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "s390_function_arg_integer", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "size", ">", "8", ")", "return", "false", ";", "if", "(", "!", "type", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "(", "TARGET_SOFT_FLOAT", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "NULLPTR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "OFFSET_TYPE", "||", "(", "TARGET_SOFT_FLOAT", "&&", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ")", ")", "return", "true", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "exact_log2", "(", "size", ")", ">=", "0", "&&", "!", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "is", "to", "be", "passed", "in", "an", "integer", "register", ",", "or", "a", "pair", "of", "integer", "registers", ",", "if", "available", "." ]

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

[]

[ "<s>", "static", "rtx", "arm_expand_neon_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", ">=", "ARM_BUILTIN_NEON_BASE", "&&", "!", "TARGET_NEON", ")", "{", "fatal_error", "(", "input_location", ",", "\"You must enable NEON instructions\"", "\" (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>)\"", "\" to use these intrinsics.\"", ")", ";", "return", "const0_rtx", ";", "}", "arm_builtin_datum", "*", "d", "=", "&", "neon_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_NEON_PATTERN_START", "]", ";", "return", "arm_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", ",", "d", ")", ";", "}", "</s>" ]

[ "Expand", "a", "Neon", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "TARGET_NEON", "holds", ".", "Most", "of", "these", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "table", "neon_builtin_data", "." ]

[ "arm", "\"You must enable NEON instructions\"", "\" (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>)\"", "\" to use these intrinsics.\"" ]

[]

[ "<s>", "static", "bool", "arm_fastmul_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "TARGET_THUMB", ")", "{", "*", "total", "=", "thumb_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "switch", "(", "code", ")", "{", "case", "MULT", ":", "if", "(", "mode", "==", "DImode", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SIGN_EXTEND", ")", ")", "{", "*", "total", "=", "8", ";", "return", "true", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "DImode", ")", "{", "*", "total", "=", "30", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", ";", "int", "cost", ",", "const_ok", "=", "const_ok_for_arm", "(", "i", ")", ";", "int", "j", ",", "booth_unit_size", ";", "cost", "=", "const_ok", "?", "4", ":", "8", ";", "booth_unit_size", "=", "8", ";", "for", "(", "j", "=", "0", ";", "i", "&&", "j", "<", "32", ";", "j", "+=", "booth_unit_size", ")", "{", "i", ">>=", "booth_unit_size", ";", "cost", "+=", "2", ";", "}", "*", "total", "=", "cost", ";", "return", "true", ";", "}", "*", "total", "=", "8", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "0", ")", ")", "?", "0", ":", "4", ")", "+", "(", "REG_OR_SUBREG_REG", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "0", ":", "4", ")", ";", "return", "true", ";", "default", ":", "*", "total", "=", "arm_rtx_costs_1", "(", "x", ",", "code", ",", "outer_code", ")", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "RTX", "cost", "for", "cores", "with", "a", "fast", "multiply", "unit", "(", "M", "variants", ")", "." ]

[ "arm", "0", "1", "0", "0", "8", "30", "1", "1", "0xffffffff", "4", "8", "8", "0", "32", "2", "8", "0", "0", "4", "1", "0", "4" ]

[]

[ "<s>", "static", "rtx", "arm_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "nregs", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "const0_rtx", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "aapcs_layout_arg", "(", "pcum", ",", "mode", ",", "type", ",", "named", ")", ";", "return", "pcum", "->", "aapcs_reg", ";", "}", "if", "(", "TARGET_IWMMXT_ABI", "&&", "arm_vector_mode_supported_p", "(", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "+", "1", ")", "{", "if", "(", "pcum", "->", "iwmmxt_nregs", "<=", "9", ")", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "iwmmxt_nregs", "+", "FIRST_IWMMXT_REGNUM", ")", ";", "else", "{", "pcum", "->", "can_split", "=", "false", ";", "return", "NULL_RTX", ";", "}", "}", "if", "(", "(", "pcum", "->", "nregs", "&", "1", ")", "&&", "ARM_DOUBLEWORD_ALIGN", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", ",", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "pcum", "->", "nregs", "++", ";", "}", "if", "(", "pcum", "->", "can_split", ")", "nregs", "=", "1", ";", "else", "nregs", "=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "if", "(", "!", "named", "||", "pcum", "->", "nregs", "+", "nregs", ">", "NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "nregs", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "the", "ARM", ",", "normally", "the", "first", "16", "bytes", "are", "passed", "in", "registers", "r0-r3", ";", "all", "other", "arguments", "are", "passed", "on", "the", "stack", ".", "If", "(", "NAMED", "==", "0", ")", "(", "which", "happens", "only", "in", "assign_parms", ",", "since", "TARGET_SETUP_INCOMING_VARARGS", "is", "defined", ")", ",", "say", "it", "is", "passed", "in", "the", "stack", "(", "function_prologue", "will", "indeed", "make", "it", "pass", "in", "the", "stack", "if", "necessary", ")", "." ]

[ "arm", "1", "9", "1", "0", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", "0", "1" ]

[]

[ "<s>", "~", "SystemZELFRegisters", "(", ")", "{", "}", "</s>" ]

[ "Destroys", "the", "object", ".", "Bogus", "destructor", "overriding", "base", "class", "destructor", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "HexagonGenPredicate", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "PredGPRs", ".", "clear", "(", ")", ";", "PUsers", ".", "clear", "(", ")", ";", "G2P", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "collectPredicateGPR", "(", "MF", ")", ";", "for", "(", "SetOfReg", "::", "iterator", "I", "=", "PredGPRs", ".", "begin", "(", ")", ",", "E", "=", "PredGPRs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processPredicateGPR", "(", "*", "I", ")", ";", "bool", "Again", ";", "do", "{", "Again", "=", "false", ";", "VectOfInst", "Processed", ",", "Copy", ";", "typedef", "VectOfInst", "::", "iterator", "iterator", ";", "Copy", "=", "PUsers", ";", "for", "(", "iterator", "I", "=", "Copy", ".", "begin", "(", ")", ",", "E", "=", "Copy", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "bool", "Done", "=", "convertToPredForm", "(", "MI", ")", ";", "if", "(", "Done", ")", "{", "Processed", ".", "insert", "(", "MI", ")", ";", "Again", "=", "true", ";", "}", "}", "Changed", "|=", "Again", ";", "auto", "Done", "=", "[", "Processed", "]", "(", "MachineInstr", "*", "MI", ")", "->", "bool", "{", "return", "Processed", ".", "count", "(", "MI", ")", ";", "}", ";", "PUsers", ".", "remove_if", "(", "Done", ")", ";", "}", "while", "(", "Again", ")", ";", "Changed", "|=", "eliminatePredCopies", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "AArch64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AArch64", "AArch64", "1", "AArch64::GPR64allRegClass", "AArch64::GPR32allRegClass", "1", "1", "0", "0", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "5", "2" ]

[]

[ "<s>", "static", "void", "mips_set_compression_mode", "(", "unsigned", "int", "compression_mode", ")", "{", "if", "(", "compression_mode", "==", "old_compression_mode", ")", "return", ";", "target_flags", "=", "mips_base_target_flags", ";", "flag_schedule_insns", "=", "mips_base_schedule_insns", ";", "flag_reorder_blocks_and_partition", "=", "mips_base_reorder_blocks_and_partition", ";", "flag_move_loop_invariants", "=", "mips_base_move_loop_invariants", ";", "align_loops", "=", "mips_base_align_loops", ";", "align_jumps", "=", "mips_base_align_jumps", ";", "align_functions", "=", "mips_base_align_functions", ";", "target_flags", "&=", "~", "(", "MASK_MIPS16", "|", "MASK_MICROMIPS", ")", ";", "target_flags", "|=", "compression_mode", ";", "if", "(", "compression_mode", "&", "MASK_MIPS16", ")", "{", "target_flags", "|=", "MASK_MIPS16", ";", "target_flags", "&=", "~", "MASK_SYNCI", ";", "flag_schedule_insns", "=", "0", ";", "flag_reorder_blocks_and_partition", "=", "0", ";", "flag_move_loop_invariants", "=", "0", ";", "target_flags", "|=", "MASK_EXPLICIT_RELOCS", ";", "targetm", ".", "min_anchor_offset", "=", "0", ";", "targetm", ".", "max_anchor_offset", "=", "127", ";", "targetm", ".", "const_anchor", "=", "0", ";", "target_flags", "&=", "~", "MASK_RELAX_PIC_CALLS", ";", "target_flags", "&=", "~", "MASK_FIX_R4000", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_OLDABI", ")", "sorry", "(", "\"MIPS16 PIC for ABIs other than o32 and o64\"", ")", ";", "if", "(", "TARGET_XGOT", ")", "sorry", "(", "\"MIPS16 -mxgot code\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT_ABI", "&&", "!", "TARGET_OLDABI", ")", "sorry", "(", "\"hard-float MIPS16 code for ABIs other than o32 and o64\"", ")", ";", "if", "(", "TARGET_MSA", ")", "sorry", "(", "\"MSA MIPS16 code\"", ")", ";", "}", "else", "{", "if", "(", "TARGET_MICROMIPS", ")", "target_flags", "&=", "~", "MASK_BRANCHLIKELY", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "align_loops", "==", "0", ")", "align_loops", "=", "8", ";", "if", "(", "align_jumps", "==", "0", ")", "align_jumps", "=", "8", ";", "if", "(", "align_functions", "==", "0", ")", "align_functions", "=", "8", ";", "}", "targetm", ".", "min_anchor_offset", "=", "-", "32768", ";", "targetm", ".", "max_anchor_offset", "=", "32767", ";", "targetm", ".", "const_anchor", "=", "0x8000", ";", "}", "mips_init_relocs", "(", ")", ";", "if", "(", "compression_mode", "&", "MASK_MIPS16", ")", "{", "if", "(", "!", "mips16_globals", ")", "mips16_globals", "=", "save_target_globals_default_opts", "(", ")", ";", "else", "restore_target_globals", "(", "mips16_globals", ")", ";", "}", "else", "if", "(", "compression_mode", "&", "MASK_MICROMIPS", ")", "{", "if", "(", "!", "micromips_globals", ")", "micromips_globals", "=", "save_target_globals_default_opts", "(", ")", ";", "else", "restore_target_globals", "(", "micromips_globals", ")", ";", "}", "else", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "old_compression_mode", "=", "compression_mode", ";", "}", "</s>" ]

[ "Set", "up", "the", "target-dependent", "global", "state", "for", "ISA", "mode", "COMPRESSION_MODE", ",", "which", "is", "either", "MASK_MIPS16", "or", "MASK_MICROMIPS", "." ]

[ "mips", "0", "0", "0", "0", "127", "0", "\"MIPS16 PIC for ABIs other than o32 and o64\"", "\"MIPS16 -mxgot code\"", "\"hard-float MIPS16 code for ABIs other than o32 and o64\"", "\"MSA MIPS16 code\"", "0", "8", "0", "8", "0", "8", "32768", "32767", "0x8000" ]

[]

[ "<s>", "const", "char", "*", "rs6000_insn_for_shift_mask", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ",", "bool", "dot", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "operands", "[", "3", "]", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "mode", "==", "DImode", "&&", "ne", "==", "0", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "4", "]", ")", "==", "LSHIFTRT", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "operands", "[", "2", "]", "=", "GEN_INT", "(", "64", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "operands", "[", "3", "]", "=", "GEN_INT", "(", "63", "-", "nb", ")", ";", "if", "(", "dot", ")", "return", "\"rld%I2cl. %0,%1,%2,%3\"", ";", "return", "\"rld%I2cl %0,%1,%2,%3\"", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "nb", "==", "63", ")", "{", "operands", "[", "3", "]", "=", "GEN_INT", "(", "63", "-", "ne", ")", ";", "if", "(", "dot", ")", "return", "\"rld%I2cr. %0,%1,%2,%3\"", ";", "return", "\"rld%I2cr %0,%1,%2,%3\"", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "operands", "[", "4", "]", ")", "!=", "LSHIFTRT", "&&", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "&&", "ne", "==", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "operands", "[", "3", "]", "=", "GEN_INT", "(", "63", "-", "nb", ")", ";", "if", "(", "dot", ")", "return", "\"rld%I2c. %0,%1,%2,%3\"", ";", "return", "\"rld%I2c %0,%1,%2,%3\"", ";", "}", "if", "(", "nb", "<", "32", "&&", "ne", "<", "32", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "4", "]", ")", "==", "LSHIFTRT", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "operands", "[", "2", "]", "=", "GEN_INT", "(", "32", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "operands", "[", "3", "]", "=", "GEN_INT", "(", "31", "-", "nb", ")", ";", "operands", "[", "4", "]", "=", "GEN_INT", "(", "31", "-", "ne", ")", ";", "if", "(", "dot", ")", "return", "\"rlw%I2nm. %0,%1,%h2,%3,%4\"", ";", "return", "\"rlw%I2nm %0,%1,%h2,%3,%4\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "instruction", "template", "for", "a", "shift", "with", "mask", "in", "mode", "MODE", ",", "with", "operands", "OPERANDS", ".", "If", "DOT", "is", "true", ",", "make", "it", "a", "record-form", "instruction", "." ]

[ "powerpcspe", "3", "0", "4", "2", "2", "64", "2", "3", "63", "\"rld%I2cl. %0,%1,%2,%3\"", "\"rld%I2cl %0,%1,%2,%3\"", "63", "3", "63", "\"rld%I2cr. %0,%1,%2,%3\"", "\"rld%I2cr %0,%1,%2,%3\"", "4", "2", "2", "3", "63", "\"rld%I2c. %0,%1,%2,%3\"", "\"rld%I2c %0,%1,%2,%3\"", "32", "32", "4", "2", "2", "32", "2", "3", "31", "4", "31", "\"rlw%I2nm. %0,%1,%h2,%3,%4\"", "\"rlw%I2nm %0,%1,%h2,%3,%4\"" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "make_range", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "AArch64::LDRWui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_undefined_decl", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "if", "(", "DECL_IN_CONSTANT_POOL", "(", "decl", ")", ")", "return", ";", "if", "(", "DECL_WEAK", "(", "decl", ")", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"PTX does not support weak declarations\"", "\" (only weak definitions)\"", ")", ";", "write_var_marker", "(", "file", ",", "false", ",", "TREE_PUBLIC", "(", "decl", ")", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.extern \"", ")", ";", "tree", "size", "=", "DECL_SIZE_UNIT", "(", "decl", ")", ";", "nvptx_assemble_decl_begin", "(", "file", ",", "name", ",", "section_for_decl", "(", "decl", ")", ",", "TREE_TYPE", "(", "decl", ")", ",", "size", "?", "tree_to_shwi", "(", "size", ")", ":", "0", ",", "DECL_ALIGN", "(", "decl", ")", ")", ";", "nvptx_assemble_decl_end", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_ASSEMBLE_UNDEFINED_DECL", ".", "Write", "an", "extern", "declaration", "only", "for", "variable", "DECL", "with", "NAME", "to", "FILE", "." ]

[ "nvptx", "\"PTX does not support weak declarations\"", "\" (only weak definitions)\"", "\"\\t.extern \"", "0" ]

[]

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

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

[ "BPF", "BPF" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "MMIX", "\"Invalid type access!\"" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MRI", ".", "getTargetRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "*", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Cond array\"", ")", ";", "unsigned", "Opc", "=", "X86", "::", "getCMovOpcode", "(", "TRI", ".", "getRegSizeInBits", "(", "RC", ")", "/", "8", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "X86", "X86", "1", "\"Invalid Cond array\"", "X86::getCMovOpcode", "8", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "Domain", ">", "0", "&&", "Domain", "<", "4", "&&", "\"Invalid execution domain\"", ")", ";", "uint16_t", "dom", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "assert", "(", "dom", "&&", "\"Not an SSE instruction\"", ")", ";", "const", "uint16_t", "*", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ")", ";", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "Subtarget", ".", "hasAVX2", "(", ")", "||", "Domain", "<", "3", ")", "&&", "\"256-bit vector operations only available in AVX2\"", ")", ";", "table", "=", "lookupAVX2", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ")", ";", "}", "if", "(", "!", "table", ")", "{", "table", "=", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ")", ";", "if", "(", "dom", "==", "3", "&&", "table", "[", "3", "]", "==", "MI", ".", "getOpcode", "(", ")", ")", "Domain", "=", "4", ";", "}", "assert", "(", "table", "&&", "\"Cannot change domain\"", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "table", "[", "Domain", "-", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "X86", "X86", "0", "4", "\"Invalid execution domain\"", "X86II::SSEDomainShift", "3", "\"Not an SSE instruction\"", "3", "\"256-bit vector operations only available in AVX2\"", "3", "3", "4", "\"Cannot change domain\"", "1" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TrueBlock", ",", "MachineBasicBlock", "*", "FalseBlock", ",", "ArrayRef", "<", "MachineOperand", ">", "Condition", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TrueBlock", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Condition", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FalseBlock", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Lanai", "::", "BT", ")", ")", ".", "addMBB", "(", "TrueBlock", ")", ";", "return", "1", ";", "}", "assert", "(", "(", "Condition", ".", "size", "(", ")", "==", "1", ")", "&&", "\"Lanai branch conditions should have one component.\"", ")", ";", "unsigned", "ConditionalCode", "=", "Condition", "[", "0", "]", ".", "getImm", "(", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Lanai", "::", "BRCC", ")", ")", ".", "addMBB", "(", "TrueBlock", ")", ".", "addImm", "(", "ConditionalCode", ")", ";", "if", "(", "!", "FalseBlock", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Lanai", "::", "BT", ")", ")", ".", "addMBB", "(", "FalseBlock", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"insertBranch must not be told to insert a fallthrough\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "Lanai::BT", "1", "1", "\"Lanai branch conditions should have one component.\"", "0", "Lanai::BRCC", "1", "Lanai::BT", "2" ]

[]

[ "<s>", "static", "void", "moxie_compute_frame", "(", "void", ")", "{", "int", "stack_alignment", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "int", "padding_locals", ";", "int", "regno", ";", "cfun", "->", "machine", "->", "local_vars_size", "=", "get_frame_size", "(", ")", ";", "padding_locals", "=", "cfun", "->", "machine", "->", "local_vars_size", "%", "stack_alignment", ";", "if", "(", "padding_locals", ")", "padding_locals", "=", "stack_alignment", "-", "padding_locals", ";", "cfun", "->", "machine", "->", "local_vars_size", "+=", "padding_locals", ";", "cfun", "->", "machine", "->", "callee_saved_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", "cfun", "->", "machine", "->", "callee_saved_reg_size", "+=", "4", ";", "cfun", "->", "machine", "->", "size_for_adjusting_sp", "=", "crtl", "->", "args", ".", "pretend_args_size", "+", "cfun", "->", "machine", "->", "local_vars_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "local", "area", "and", "the", "size", "to", "be", "adjusted", "by", "the", "*", "prologue", "and", "epilogue", "." ]

[ "moxie", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "int", "nvptx_sese_number", "(", "int", "n", ",", "int", "p", ",", "int", "dir", ",", "basic_block", "b", ",", "auto_vec", "<", "basic_block", ">", "*", "list", ")", "{", "if", "(", "BB_GET_SESE", "(", "b", ")", ")", "return", "n", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Block %d(%d), parent (%d), orientation %+d\\n\"", ",", "b", "->", "index", ",", "n", ",", "p", ",", "dir", ")", ";", "BB_SET_SESE", "(", "b", ",", "new", "bb_sese", "(", "n", ",", "p", ",", "dir", ")", ")", ";", "p", "=", "n", ";", "n", "+=", "3", ";", "list", "->", "quick_push", "(", "b", ")", ";", "for", "(", "unsigned", "ix", "=", "2", ";", "ix", ";", "ix", "--", ")", "{", "vec", "<", "edge", ",", "va_gc", ">", "*", "edges", "=", "dir", ">", "0", "?", "b", "->", "succs", ":", "b", "->", "preds", ";", "size_t", "offset", "=", "(", "dir", ">", "0", "?", "offsetof", "(", "edge_def", ",", "dest", ")", ":", "offsetof", "(", "edge_def", ",", "src", ")", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "edges", ")", "{", "basic_block", "target", "=", "*", "(", "basic_block", "*", ")", "(", "(", "char", "*", ")", "e", "+", "offset", ")", ";", "if", "(", "target", "->", "flags", "&", "BB_VISITED", ")", "n", "=", "nvptx_sese_number", "(", "n", ",", "p", ",", "dir", ",", "target", ",", "list", ")", ";", "}", "dir", "=", "-", "dir", ";", "}", "return", "n", ";", "}", "</s>" ]

[ "DFS", "walk", "creating", "SESE", "data", "structures", ".", "Only", "cover", "nodes", "with", "BB_VISITED", "set", ".", "Append", "discovered", "blocks", "to", "LIST", ".", "We", "number", "in", "increments", "of", "3", "so", "that", "the", "above", "and", "below", "pseudo", "nodes", "can", "be", "implicitly", "numbered", "too", "." ]

[ "nvptx", "\"Block %d(%d), parent (%d), orientation %+d\\n\"", "3", "2", "0", "0" ]

[]

[ "<s>", "int", "fp_one_operand", "(", "rtx", "op", ")", "{", "REAL_VALUE_TYPE", "r", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "0", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "return", "REAL_VALUES_EQUAL", "(", "r", ",", "dconst1", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "OP", "is", "a", "floating", "point", "value", "with", "value", "1.0", "." ]

[ "sh", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitCallFramePseudo: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "const", "ARCInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineInstr", "&", "Old", "=", "*", "I", ";", "DebugLoc", "dl", "=", "Old", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Amt", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "auto", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Amt", ">", "AFI", "->", "MaxCallStackReq", "&&", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKDOWN", ")", "AFI", "->", "MaxCallStackReq", "=", "Amt", ";", "}", "else", "{", "if", "(", "Amt", "!=", "0", ")", "{", "assert", "(", "(", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKDOWN", "||", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKUP", ")", "&&", "\"Unknown Frame Pseudo.\"", ")", ";", "bool", "IsAdd", "=", "(", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKUP", ")", ";", "emitRegUpdate", "(", "MBB", ",", "I", ",", "dl", ",", "ARC", "::", "SP", ",", "Amt", ",", "IsAdd", ",", "TII", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"EmitCallFramePseudo: \"", "\"\\n\"", "ARC", "ARC", "0", "ARC", "ARC::ADJCALLSTACKDOWN", "0", "ARC::ADJCALLSTACKDOWN", "ARC::ADJCALLSTACKUP", "\"Unknown Frame Pseudo.\"", "ARC::ADJCALLSTACKUP", "ARC::SP" ]

[]

[ "<s>", "ValueType", "MetadataStreamer", "::", "getValueType", "(", "Type", "*", "Ty", ",", "StringRef", "TypeName", ")", "const", "{", "switch", "(", "Ty", "->", "getTypeID", "(", ")", ")", "{", "case", "Type", "::", "IntegerTyID", ":", "{", "auto", "Signed", "=", "!", "TypeName", ".", "startswith", "(", "\"u\"", ")", ";", "switch", "(", "Ty", "->", "getIntegerBitWidth", "(", ")", ")", "{", "case", "8", ":", "return", "Signed", "?", "ValueType", "::", "I8", ":", "ValueType", "::", "U8", ";", "case", "16", ":", "return", "Signed", "?", "ValueType", "::", "I16", ":", "ValueType", "::", "U16", ";", "case", "32", ":", "return", "Signed", "?", "ValueType", "::", "I32", ":", "ValueType", "::", "U32", ";", "case", "64", ":", "return", "Signed", "?", "ValueType", "::", "I64", ":", "ValueType", "::", "U64", ";", "default", ":", "return", "ValueType", "::", "Struct", ";", "}", "}", "case", "Type", "::", "HalfTyID", ":", "return", "ValueType", "::", "F16", ";", "case", "Type", "::", "FloatTyID", ":", "return", "ValueType", "::", "F32", ";", "case", "Type", "::", "DoubleTyID", ":", "return", "ValueType", "::", "F64", ";", "case", "Type", "::", "PointerTyID", ":", "return", "getValueType", "(", "Ty", "->", "getPointerElementType", "(", ")", ",", "TypeName", ")", ";", "case", "Type", "::", "VectorTyID", ":", "return", "getValueType", "(", "Ty", "->", "getVectorElementType", "(", ")", ",", "TypeName", ")", ";", "default", ":", "return", "ValueType", "::", "Struct", ";", "}", "}", "</s>" ]

[ "Return", "the", "ValueType", "of", "the", "referenced", "return", "value", "." ]

[ "AMDGPU", "\"u\"", "8", "16", "32", "64" ]

[]

[ "<s>", "static", "int", "s390_sched_reorder", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "nreadyp", ",", "int", "clock", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "s390_tune", "==", "PROCESSOR_2097_Z10", "&&", "reload_completed", "&&", "*", "nreadyp", ">", "1", ")", "s390_z10_prevent_earlyload_conflicts", "(", "ready", ",", "nreadyp", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2827_ZEC12", "&&", "reload_completed", "&&", "*", "nreadyp", ">", "1", ")", "{", "int", "i", ";", "int", "last_index", "=", "*", "nreadyp", "-", "1", ";", "int", "max_index", "=", "-", "1", ";", "int", "max_score", "=", "-", "1", ";", "rtx_insn", "*", "tmp", ";", "for", "(", "i", "=", "last_index", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "score", ";", "if", "(", "recog_memoized", "(", "ready", "[", "i", "]", ")", "<", "0", ")", "continue", ";", "score", "=", "s390_sched_score", "(", "ready", "[", "i", "]", ")", ";", "if", "(", "score", ">", "max_score", ")", "{", "max_score", "=", "score", ";", "max_index", "=", "i", ";", "}", "}", "if", "(", "max_index", "!=", "-", "1", ")", "{", "if", "(", "max_index", "!=", "last_index", ")", "{", "tmp", "=", "ready", "[", "max_index", "]", ";", "ready", "[", "max_index", "]", "=", "ready", "[", "last_index", "]", ";", "ready", "[", "last_index", "]", "=", "tmp", ";", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: move insn %d to the top of list\\n\"", ",", "INSN_UID", "(", "ready", "[", "last_index", "]", ")", ")", ";", "}", "else", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: best insn %d already on top\\n\"", ",", "INSN_UID", "(", "ready", "[", "last_index", "]", ")", ")", ";", "}", "if", "(", "verbose", ">", "5", ")", "{", "fprintf", "(", "file", ",", "\"ready list ooo attributes - sched state: %d\\n\"", ",", "s390_sched_state", ")", ";", "for", "(", "i", "=", "last_index", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "unsigned", "int", "sched_mask", ";", "rtx_insn", "*", "insn", "=", "ready", "[", "i", "]", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "continue", ";", "sched_mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: insn %d score: %d: \"", ",", "INSN_UID", "(", "insn", ")", ",", "s390_sched_score", "(", "insn", ")", ")", ";", "(", "(", "M", ")", "&", "sched_mask", ")", "?", "#", "ATTR", ":", "\"\"", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_CRACKED", ",", "cracked", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_EXPANDED", ",", "expanded", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_ENDGROUP", ",", "endgroup", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_GROUPALONE", ",", "groupalone", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "unsigned", "int", "unit_mask", ",", "m", "=", "1", ";", "int", "units", ",", "j", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\"(units:\"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "fprintf", "(", "file", ",", "\" u%d\"", ",", "j", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "}", "}", "return", "s390_issue_rate", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "via", "hook", "TARGET_SCHED_REORDER", "before", "issuing", "one", "insn", "from", "list", "READY", "which", "contains", "*", "NREADYP", "entries", ".", "For", "target", "z10", "it", "reorders", "load", "instructions", "to", "avoid", "early", "load", "conflicts", "in", "the", "floating", "point", "pipeline" ]

[ "s390", "1", "1", "1", "1", "1", "0", "0", "1", "5", "\";;\\t\\tBACKEND: move insn %d to the top of list\\n\"", "5", "\";;\\t\\tBACKEND: best insn %d already on top\\n\"", "5", "\"ready list ooo attributes - sched state: %d\\n\"", "0", "0", "\";;\\t\\tBACKEND: insn %d score: %d: \"", "\"\"", "1", "\"(units:\"", "0", "1", "\" u%d\"", "\")\"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "loongarch_pass_mode_in_fpr_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "UNITS_PER_FP_ARG", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "return", "2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "If", "MODE", "represents", "an", "argument", "that", "can", "be", "passed", "or", "returned", "in", "floating-point", "registers", ",", "return", "the", "number", "of", "registers", ",", "else", "0", "." ]

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

[]

[ "<s>", "unsigned", "getOperandsScalarizationOverhead", "(", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "unsigned", "VF", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Estimate", "the", "overhead", "of", "scalarizing", "an", "instructions", "unique", "non-constant", "operands", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumTCycles", ",", "unsigned", "ExtraTCycles", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumFCycles", ",", "unsigned", "ExtraFCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Wasn't expecting to be able to lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAMPOLINE", ":", "return", "LowerTRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ",", "VarArgsStackOffset", ",", "VarArgsNumGPR", ",", "VarArgsNumFPR", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ",", "VarArgsStackOffset", ",", "VarArgsNumGPR", ",", "VarArgsNumFPR", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "Op", ".", "getDebugLoc", "(", ")", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Wasn't expecting to be able to lower this!\"", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SETCC", "ISD::TRAMPOLINE", "ISD::VASTART", "PPC", "ISD::VAARG", "PPC", "ISD::STACKRESTORE", "PPC", "ISD::DYNAMIC_STACKALLOC", "PPC", "ISD::SELECT_CC", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::FLT_ROUNDS_", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SCALAR_TO_VECTOR", "ISD::MUL", "ISD::RETURNADDR", "ISD::FRAMEADDR" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'A'", ":", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "O", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "ARM", "ARM", "0", "1", "0", "0", "ARM", "\"unexpected inline asm memory operand\"", "\"[\"", "ARM", "\"]\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MF", ".", "setHasWinCFI", "(", "false", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "STI", ".", "is64Bit", "(", ")", "||", "!", "MF", ".", "hasEHFunclets", "(", ")", "||", "classifyEHPersonality", "(", "F", ".", "getPersonalityFn", "(", ")", ")", "!=", "EHPersonality", "::", "MSVC_CXX", ")", "return", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "-", "SlotSize", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "I", "<", "0", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", ".", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "WinEHTryBlockMapEntry", "&", "TBME", ":", "EHInfo", ".", "TryBlockMap", ")", "{", "for", "(", "WinEHHandlerType", "&", "H", ":", "TBME", ".", "HandlerArray", ")", "{", "int", "FrameIndex", "=", "H", ".", "CatchObj", ".", "FrameIndex", ";", "if", "(", "FrameIndex", "!=", "INT_MAX", ")", "{", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "Align", ";", "MinFixedObjOffset", "-=", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "MFI", ".", "setObjectOffset", "(", "FrameIndex", ",", "MinFixedObjOffset", ")", ";", "}", "}", "}", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "8", ";", "int64_t", "UnwindHelpOffset", "=", "MinFixedObjOffset", "-", "SlotSize", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateFixedObject", "(", "SlotSize", ",", "UnwindHelpOffset", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64mi32", ")", ")", ",", "UnwindHelpFI", ")", ".", "addImm", "(", "-", "2", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "8", "X86::MOV64mi32", "2" ]

[]

[ "<s>", "void", "HexagonTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ",", "DAG", ")", ")", "{", "LowerHvxOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "if", "(", "!", "Results", ".", "empty", "(", ")", ")", "return", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "STORE", ")", "return", "TargetLowering", "::", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::STORE" ]

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createX86MachObjectWriter", "(", "OS", ",", "true", ",", "MachO", "::", "CPU_TYPE_X86_64", ",", "MachO", "::", "CPU_SUBTYPE_X86_64_ALL", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "bool", "KudeyarDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Ret", "=", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "void", "neon_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "0", ",", "one_var", "=", "-", "1", ";", "bool", "all_same", "=", "true", ";", "rtx", "x", ",", "mem", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "x", ")", ")", "++", "n_var", ",", "one_var", "=", "i", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "rtx", "constant", "=", "neon_make_constant", "(", "vals", ")", ";", "if", "(", "constant", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "target", ",", "constant", ")", ";", "return", ";", "}", "}", "if", "(", "all_same", "&&", "GET_MODE_SIZE", "(", "inner_mode", ")", "<=", "4", ")", "{", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_vec_duplicate", "(", "mode", ",", "x", ")", ")", ")", ";", "return", ";", "}", "if", "(", "n_var", "==", "1", ")", "{", "rtx", "copy", "=", "copy_rtx", "(", "vals", ")", ";", "rtx", "merge_mask", "=", "GEN_INT", "(", "1", "<<", "one_var", ")", ";", "XVECEXP", "(", "copy", ",", "0", ",", "one_var", ")", "=", "XVECEXP", "(", "vals", ",", "0", ",", "(", "one_var", "+", "1", ")", "%", "n_elts", ")", ";", "neon_expand_vector_init", "(", "target", ",", "copy", ")", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ")", ";", "emit_insn", "(", "gen_vec_set_internal", "(", "mode", ",", "target", ",", "x", ",", "merge_mask", ",", "target", ")", ")", ";", "return", ";", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "Initialize", "vector", "TARGET", "to", "VALS", "." ]

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

[]

[ "<s>", "const", "SICTargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "SICTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "SIC", "SIC", "SIC" ]

[]

[ "<s>", "void", "SPUTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "Opc", "=", "(", "unsigned", ")", "N", "->", "getOpcode", "(", ")", ";", "EVT", "OpVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"SPUTargetLowering::ReplaceNodeResults(): need to fix this!\\n\"", ";", "errs", "(", ")", "<<", "\"Op.getOpcode() = \"", "<<", "Opc", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"*Op.getNode():\\n\"", ";", "N", "->", "dump", "(", ")", ";", "abort", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "CellSPU", "SPU", "0", "\"SPUTargetLowering::ReplaceNodeResults(): need to fix this!\\n\"", "\"Op.getOpcode() = \"", "\"\\n\"", "\"*Op.getNode():\\n\"" ]

[]

[ "<s>", "void", "ARCompactInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "int", "DestReg", ",", "unsigned", "int", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARC", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ARC::MOVrr" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "TM", "=", "&", "MF", "->", "getTarget", "(", ")", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StackOffset", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "IsFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "IsFixed", "?", "TRI", "->", "getFramePtr", "(", ")", ":", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "bool", "IsWin64Prologue", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "int64_t", "FPDelta", "=", "0", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", "&&", "Offset", ">=", "0", ")", "{", "Offset", "+=", "getOffsetOfLocalArea", "(", ")", ";", "}", "if", "(", "IsWin64Prologue", ")", "{", "assert", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "StackSize", "%", "16", ")", "==", "8", ")", ";", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "X86FI", "->", "getRestoreBasePointer", "(", ")", ")", "FrameSize", "+=", "SlotSize", ";", "uint64_t", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "uint64_t", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "NumBytes", ")", ";", "if", "(", "FI", "&&", "FI", "==", "X86FI", "->", "getFAIndex", "(", ")", ")", "return", "StackOffset", "::", "getFixed", "(", "-", "SEHFrameOffset", ")", ";", "FPDelta", "=", "FrameSize", "-", "SEHFrameOffset", ";", "assert", "(", "(", "!", "MFI", ".", "hasCalls", "(", ")", "||", "(", "FPDelta", "%", "16", ")", "==", "0", ")", "&&", "\"FPDelta isn't aligned per the Win64 ABI!\"", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "\"VLAs and dynamic stack realign, but no FP?!\"", ")", ";", "if", "(", "FI", "<", "0", ")", "{", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "SlotSize", "+", "FPDelta", ")", ";", "}", "else", "{", "assert", "(", "isAligned", "(", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "-", "(", "Offset", "+", "StackSize", ")", ")", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "}", "}", "else", "if", "(", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "0", ")", "{", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "SlotSize", "+", "FPDelta", ")", ";", "}", "else", "{", "assert", "(", "isAligned", "(", "MFI", ".", "getObjectAlign", "(", "FI", ")", ",", "-", "(", "Offset", "+", "StackSize", ")", ")", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "}", "}", "else", "{", "if", "(", "!", "HasFP", ")", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "StackSize", ")", ";", "Offset", "+=", "SlotSize", ";", "int", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", "+", "FPDelta", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "16", "8", "X86", "X86", "16", "0", "\"FPDelta isn't aligned per the Win64 ABI!\"", "\"VLAs and dynamic stack realign, but no FP?!\"", "0", "0", "X86", "0" ]

[]

[ "<s>", "unsigned", "SPUInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPU", "::", "LQDv16i8", ":", "case", "SPU", "::", "LQDv8i16", ":", "case", "SPU", "::", "LQDv4i32", ":", "case", "SPU", "::", "LQDv4f32", ":", "case", "SPU", "::", "LQDv2f64", ":", "case", "SPU", "::", "LQDr128", ":", "case", "SPU", "::", "LQDr64", ":", "case", "SPU", "::", "LQDr32", ":", "case", "SPU", "::", "LQDr16", ":", "{", "const", "MachineOperand", "MOp1", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "const", "MachineOperand", "MOp2", "=", "MI", "->", "getOperand", "(", "2", ")", ";", "if", "(", "MOp1", ".", "isImm", "(", ")", "&&", "MOp2", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MOp2", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU::LQDv16i8", "SPU::LQDv8i16", "SPU::LQDv4i32", "SPU::LQDv4f32", "SPU::LQDv2f64", "SPU::LQDr128", "SPU::LQDr64", "SPU::LQDr32", "SPU::LQDr16", "1", "2", "0", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "LanaiSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LanaiSubtarget", ">", "(", ")", ";", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "static", "void", "mark_reg_gr_used_mask", "(", "rtx", "reg", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "regno", "<", "32", ")", "{", "unsigned", "int", "i", ",", "n", "=", "REG_NREGS", "(", "reg", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "++", "i", ")", "current_frame_info", ".", "gr_used_mask", "|=", "1", "<<", "(", "regno", "+", "i", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "ia64_compute_frame_size", ",", "called", "through", "diddle_return_value", ".", "Mark", "REG", "in", "current_frame_info.gr_used_mask", "." ]

[ "ia64", "32", "0", "1" ]

[]

[ "<s>", "static", "void", "record_memory_reference", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_itanium_class", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "switch", "(", "insn_class", ")", "{", "case", "ITANIUM_CLASS_FLD", ":", "case", "ITANIUM_CLASS_LD", ":", "mem_ops_in_group", "[", "current_cycle", "%", "4", "]", "++", ";", "break", ";", "case", "ITANIUM_CLASS_STF", ":", "case", "ITANIUM_CLASS_ST", ":", "mem_ops_in_group", "[", "(", "current_cycle", "+", "3", ")", "%", "4", "]", "++", ";", "break", ";", "default", ":", ";", "}", "}", "</s>" ]

[ "If", "INSN", "is", "a", "memory", "reference", ",", "memoize", "it", "in", "MEM_OPS_IN_GROUP", "global", "array", "(", "taking", "account", "for", "3-cycle", "cache", "reference", "postponing", "for", "stores", ":", "Intel", "Itanium", "2", "Reference", "Manual", "for", "Software", "Development", "and", "Optimization", ",", "6.7.3.1", ")", "." ]

[ "ia64", "4", "3", "4" ]

[]

[ "<s>", "unsigned", "MCS51InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "MCS51", "::", "RJMPk", "&&", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "MCS51CC", "::", "COND_INVALID", ")", "{", "break", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "MCS51", "MCS51", "0", "0", "MCS51::RJMPk", "MCS51CC::COND_INVALID" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "MF", "->", "begin", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "Alpha" ]

[]

[ "<s>", "static", "char", "*", "construct_fntype_id", "(", "prototype", "*", "protoptr", ")", "{", "int", "len", "=", "protoptr", "->", "nargs", "?", "(", "protoptr", "->", "nargs", "+", "1", ")", "*", "9", "+", "6", ":", "17", ";", "char", "*", "buf", "=", "(", "char", "*", ")", "malloc", "(", "len", ")", ";", "int", "bufi", "=", "0", ";", "if", "(", "protoptr", "->", "rettype", ".", "ispointer", ")", "buf", "[", "bufi", "++", "]", "=", "'p'", ";", "if", "(", "protoptr", "->", "rettype", ".", "isvoid", ")", "buf", "[", "bufi", "++", "]", "=", "'v'", ";", "else", "{", "if", "(", "protoptr", "->", "rettype", ".", "isunsigned", ")", "buf", "[", "bufi", "++", "]", "=", "'u'", ";", "if", "(", "protoptr", "->", "rettype", ".", "isvector", ")", "complete_vector_type", "(", "&", "protoptr", "->", "rettype", ",", "buf", ",", "&", "bufi", ")", ";", "else", "complete_base_type", "(", "&", "protoptr", "->", "rettype", ",", "buf", ",", "&", "bufi", ")", ";", "}", "memcpy", "(", "&", "buf", "[", "bufi", "]", ",", "\"_ftype\"", ",", "6", ")", ";", "bufi", "+=", "6", ";", "if", "(", "!", "protoptr", "->", "nargs", ")", "{", "memcpy", "(", "&", "buf", "[", "bufi", "]", ",", "\"_v\"", ",", "2", ")", ";", "bufi", "+=", "2", ";", "}", "else", "{", "typelist", "*", "argptr", "=", "protoptr", "->", "args", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "protoptr", "->", "nargs", ";", "i", "++", ",", "argptr", "=", "argptr", "->", "next", ")", "{", "assert", "(", "argptr", ")", ";", "buf", "[", "bufi", "++", "]", "=", "'_'", ";", "if", "(", "argptr", "->", "info", ".", "isconst", "&&", "argptr", "->", "info", ".", "base", "==", "BT_INT", "&&", "!", "argptr", "->", "info", ".", "ispointer", ")", "{", "buf", "[", "bufi", "++", "]", "=", "'c'", ";", "buf", "[", "bufi", "++", "]", "=", "'i'", ";", "continue", ";", "}", "if", "(", "argptr", "->", "info", ".", "ispointer", ")", "{", "if", "(", "argptr", "->", "info", ".", "isvoid", ")", "{", "if", "(", "argptr", "->", "info", ".", "isconst", ")", "{", "memcpy", "(", "&", "buf", "[", "bufi", "]", ",", "\"pcvoid\"", ",", "6", ")", ";", "bufi", "+=", "6", ";", "continue", ";", "}", "else", "{", "buf", "[", "bufi", "++", "]", "=", "'p'", ";", "buf", "[", "bufi", "++", "]", "=", "'v'", ";", "continue", ";", "}", "}", "else", "buf", "[", "bufi", "++", "]", "=", "'p'", ";", "}", "if", "(", "argptr", "->", "info", ".", "isunsigned", ")", "buf", "[", "bufi", "++", "]", "=", "'u'", ";", "if", "(", "argptr", "->", "info", ".", "isvector", ")", "complete_vector_type", "(", "&", "argptr", "->", "info", ",", "buf", ",", "&", "bufi", ")", ";", "else", "complete_base_type", "(", "&", "argptr", "->", "info", ",", "buf", ",", "&", "bufi", ")", ";", "}", "assert", "(", "!", "argptr", ")", ";", "}", "buf", "[", "bufi", "]", "=", "'\\0'", ";", "rbt_insert", "(", "&", "fntype_rbt", ",", "buf", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Build", "a", "function", "type", "descriptor", "identifier", "from", "the", "return", "type", "and", "argument", "types", "described", "by", "PROTOPTR", ",", "and", "store", "it", "if", "it", "does", "not", "already", "exist", ".", "Return", "the", "identifier", "." ]

[ "rs6000", "1", "9", "6", "17", "0", "\"_ftype\"", "6", "6", "\"_v\"", "2", "2", "0", "\"pcvoid\"", "6", "6" ]

[]

[ "<s>", "bool", "Z80AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'X'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"$\"", "<<", "std", "::", "hex", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"$\"", "<<", "std", "::", "hex", "<<", "(", "MO", ".", "getImm", "(", ")", "&", "0xffff", ")", ";", "return", "false", ";", "case", "'d'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'m'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", "-", "1", ";", "return", "false", ";", "case", "'z'", ":", "{", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "int64_t", "val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "val", ")", "{", "O", "<<", "val", ";", "}", "else", "{", "O", "<<", "\"$0\"", ";", "}", "return", "false", ";", "}", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "1", "0", "0", "\"$\"", "\"$\"", "0xffff", "1", "\"$0\"" ]

[]

[ "<s>", "void", "VideocoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "int", "FIOperandNo", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNo", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNo", ")", ".", "ChangeToRegister", "(", "VC", "::", "SP", ",", "false", ")", ";", "int", "OffsetOperandNo", "=", "FIOperandNo", "+", "1", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "0", "\"Unexpected\"", "VC::SP", "1" ]

[]

[ "<s>", "tree", "builtin_decl", "(", "unsigned", "int", "code", ",", "bool", ")", "{", "if", "(", "code", ">=", "vec_safe_length", "(", "registered_functions", ")", ")", "return", "error_mark_node", ";", "return", "(", "*", "registered_functions", ")", "[", "code", "]", "->", "decl", ";", "}", "</s>" ]

[ "Return", "the", "function", "decl", "with", "RVV", "function", "subcode", "CODE", ",", "or", "error_mark_node", "if", "no", "such", "function", "exists", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "push_regs", "(", "HARD_REG_SET", "*", "mask", ",", "int", "interrupt_handler", ")", "{", "int", "i", ";", "int", "skip_fpscr", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "==", "FIRST_FP_REG", "&&", "interrupt_handler", "&&", "TARGET_FMOVD", "&&", "hard_regs_intersect_p", "(", "mask", ",", "&", "reg_class_contents", "[", "DF_REGS", "]", ")", ")", "{", "HARD_REG_SET", "unsaved", ";", "push", "(", "FPSCR_REG", ")", ";", "COMPL_HARD_REG_SET", "(", "unsaved", ",", "*", "mask", ")", ";", "fpscr_set_from_mem", "(", "NORMAL_MODE", "(", "FP_MODE", ")", ",", "unsaved", ")", ";", "skip_fpscr", "=", "1", ";", "}", "if", "(", "i", "!=", "PR_REG", "&&", "(", "i", "!=", "FPSCR_REG", "||", "!", "skip_fpscr", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "push", "(", "i", ")", ";", "}", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "PR_REG", ")", ")", "push", "(", "PR_REG", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "push", "the", "regs", "specified", "in", "the", "mask", ".", "remember", "that", "the", "mask", "is", "of", "the", "internal", "shape", "of", "the", "regs", ",", "not", "the", "external", "shape", "-", "so", "go", "through", "the", "renumber", "vector" ]

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

[]

[ "<s>", "static", "bool", "pru_valid_const_ubyte_offset", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "bool", "valid", "=", "UBYTE_INT", "(", "offset", ")", ";", "if", "(", "valid", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "GET_MODE_SIZE", "(", "SImode", ")", ")", "valid", "=", "UBYTE_INT", "(", "offset", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ";", "return", "valid", ";", "}", "</s>" ]

[ "Return", "true", "if", "given", "xbbo", "constant", "OFFSET", "is", "valid", "." ]

[ "pru", "1" ]

[]

[ "<s>", "OpRef", "HvxSelector", "::", "concat", "(", "OpRef", "Lo", ",", "OpRef", "Hi", ",", "ResultStack", "&", "Results", ")", "{", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "__func__", "<<", "'\\n'", ";", "}", ")", ";", "const", "SDLoc", "&", "dl", "(", "Results", ".", "InpNode", ")", ";", "Results", ".", "push", "(", "TargetOpcode", "::", "REG_SEQUENCE", ",", "getPairVT", "(", "MVT", "::", "i8", ")", ",", "{", "DAG", ".", "getTargetConstant", "(", "Hexagon", "::", "HvxWRRegClassID", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Lo", ",", "DAG", ".", "getTargetConstant", "(", "Hexagon", "::", "vsub_lo", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Hi", ",", "DAG", ".", "getTargetConstant", "(", "Hexagon", "::", "vsub_hi", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "}", ")", ";", "return", "OpRef", "::", "res", "(", "Results", ".", "top", "(", ")", ")", ";", "}", "</s>" ]

[ "Concatenate", "the", "bits", "from", "Lo", "onto", "the", "bottom", "of", "*", "this", "." ]

[ "Hexagon", "\"isel\"", "MVT::i8", "Hexagon::HvxWRRegClassID", "MVT::i32", "Hexagon::vsub_lo", "MVT::i32", "Hexagon::vsub_hi", "MVT::i32" ]

[]

[ "<s>", "bool", "HexagonFixupHwLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "return", "fixupLoopInstrs", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "LLVM_FALLTHROUGH", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_X", ":", "if", "(", "!", "selectAddr", "(", "nullptr", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Patmos" ]

[]

[ "<s>", "poly_int64", "h8300_push_rounding", "(", "poly_int64", "bytes", ")", "{", "return", "(", "(", "bytes", "+", "PARM_BOUNDARY", "/", "8", "-", "1", ")", "&", "(", "-", "PARM_BOUNDARY", "/", "8", ")", ")", ";", "}", "</s>" ]

[ "Implement", "PUSH_ROUNDING", ".", "On", "the", "H8/300", ",", "@", "-sp", "really", "pushes", "a", "byte", "if", "you", "ask", "it", "to", "-", "but", "that", "'s", "dangerous", ",", "so", "we", "claim", "that", "it", "always", "pushes", "a", "word", ",", "then", "we", "catch", "the", "mov.b", "rx", ",", "@", "-sp", "and", "turn", "it", "into", "a", "mov.w", "rx", ",", "@", "-sp", "on", "output", ".", "On", "the", "H8/300H", ",", "we", "simplify", "TARGET_QUICKCALL", "by", "setting", "this", "to", "4", "and", "doing", "a", "similar", "thing", "." ]

[ "h8300", "8", "1", "8" ]

[]

[ "<s>", "static", "void", "expand_interrupt_handler_epilogue", "(", "rtx", "spreg", ",", "e_funkind", "fkind", ",", "bool", "all", ")", "{", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "rtx", "postinc1", "=", "gen_rtx_POST_INC", "(", "SImode", ",", "spreg", ")", ";", "rtx", "postinc", "=", "gen_rtx_MEM", "(", "SImode", ",", "postinc1", ")", ";", "MEM_VOLATILE_P", "(", "postinc", ")", "=", "1", ";", "do_unlink", "(", "spreg", ",", "get_frame_size", "(", ")", ",", "all", ",", "1", ")", ";", "if", "(", "lookup_attribute", "(", "\"nesting\"", ",", "attrs", ")", ")", "{", "rtx", "srcreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "ret_regs", "[", "fkind", "]", ")", ";", "emit_move_insn", "(", "srcreg", ",", "postinc", ")", ";", "}", "if", "(", "!", "crtl", "->", "is_leaf", ")", "all", "=", "true", ";", "expand_epilogue_reg_restore", "(", "spreg", ",", "all", ",", "true", ")", ";", "if", "(", "fkind", "==", "EXCPT_HANDLER", ")", "emit_insn", "(", "gen_addsi3", "(", "spreg", ",", "spreg", ",", "GEN_INT", "(", "12", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx_REG", "(", "Pmode", ",", "ret_regs", "[", "fkind", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "an", "epilogue", "suitable", "for", "a", "function", "of", "kind", "FKIND", ".", "This", "is", "called", "for", "interrupt", "and", "exception", "handler", "epilogues", ".", "SPREG", "contains", "(", "reg", ":", "SI", "REG_SP", ")", "." ]

[ "bfin", "1", "1", "\"nesting\"", "12" ]

[]

[ "<s>", "static", "int", "sparc_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "int", "slotno", ",", "regno", ",", "padding", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "0", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "TARGET_ARCH32", ")", "{", "if", "(", "(", "slotno", "+", "(", "mode", "==", "BLKmode", "?", "ROUND_ADVANCE", "(", "int_size_in_bytes", "(", "type", ")", ")", ":", "ROUND_ADVANCE", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ">", "SPARC_INT_ARG_MAX", ")", "return", "(", "SPARC_INT_ARG_MAX", "-", "slotno", ")", "*", "UNITS_PER_WORD", ";", "}", "else", "{", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "!", "(", "TARGET_FPU", "&&", "named", ")", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "if", "(", "(", "slotno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ")", ">", "SPARC_FP_ARG_MAX", ")", "return", "UNITS_PER_WORD", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "of", "registers", "used", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Any", "arg", "that", "starts", "in", "the", "first", "6", "regs", "but", "wo", "n't", "entirely", "fit", "in", "them", "needs", "partial", "registers", "on", "v8", ".", "On", "v9", ",", "structures", "with", "integer", "values", "in", "arg", "slots", "5,6", "will", "be", "passed", "in", "%", "o5", "and", "SP+176", ",", "and", "complex", "fp", "values", "that", "begin", "in", "the", "last", "fp", "reg", "[", "where", "``", "last", "fp", "reg", "''", "varies", "with", "the", "mode", "]", "will", "be", "split", "between", "that", "reg", "and", "memory", "." ]

[ "sparc", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "loongarch_can_use_return_insn", "(", "void", ")", "{", "return", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame", ".", "total_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableRedZone", ")", "return", "false", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "unsigned", "RedZoneSize", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "getRedZoneSize", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "if", "(", "!", "RedZoneSize", ")", "return", "false", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";", "return", "!", "(", "MFI", ".", "hasCalls", "(", ")", "||", "hasFP", "(", "MF", ")", "||", "NumBytes", ">", "RedZoneSize", "||", "getSVEStackSize", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "Can", "this", "function", "use", "the", "red", "zone", "for", "local", "allocations", "." ]

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

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LSBaseSDNode", "*", "LSN", "=", "dyn_cast", "<", "LSBaseSDNode", ">", "(", "N", ")", ";", "if", "(", "!", "LSN", ")", "return", "false", ";", "EVT", "VT", "=", "LSN", "->", "getMemoryVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "IsLegalType", "=", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "v2i16", "||", "VT", "==", "MVT", "::", "v2i32", "||", "VT", "==", "MVT", "::", "v4i8", "||", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i8", "||", "Subtarget", ".", "isHVXVectorType", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "if", "(", "!", "IsLegalType", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "Op", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", ")", "return", "false", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "int32_t", "V", "=", "cast", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "Subtarget", ".", "getInstrInfo", "(", ")", "->", "isValidAutoIncImm", "(", "VT", ",", "V", ")", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "Hexagon", "Hexagon", "ISD::MemIndexedMode", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::v2i16", "MVT::v2i32", "MVT::v4i8", "MVT::v4i16", "MVT::v8i8", "ISD::ADD", "0", "1", "ISD::POST_INC" ]

[]

[ "<s>", "bool", "useAA", "(", ")", "const", "override", "{", "return", "IsCheri", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "Mips" ]

[]

[ "<s>", "int", "m32c_class_max_nregs", "(", "int", "regclass", ",", "enum", "machine_mode", "mode", ")", "{", "int", "rn", ",", "max", "=", "0", ";", "for", "(", "rn", "=", "0", ";", "rn", "<", "FIRST_PSEUDO_REGISTER", ";", "rn", "++", ")", "if", "(", "class_contents", "[", "regclass", "]", "[", "0", "]", "&", "(", "1", "<<", "rn", ")", ")", "{", "int", "n", "=", "m32c_hard_regno_nregs", "(", "rn", ",", "mode", ")", ";", "if", "(", "max", "<", "n", ")", "max", "=", "n", ";", "}", "return", "max", ";", "}", "</s>" ]

[ "Implements", "CLASS_MAX_NREGS", ".", "We", "calculate", "this", "according", "to", "its", "documented", "meaning", ",", "to", "avoid", "potential", "inconsistencies", "with", "actual", "class", "definitions", "." ]

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

[]

[ "<s>", "bool", "VERegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "if", "(", "getFrameLowering", "(", "MF", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "void", "neon_lane_bounds", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ")", "{", "bounds_check", "(", "operand", ",", "low", ",", "high", ",", "\"lane out of range\"", ")", ";", "}", "</s>" ]

[ "Bounds-check", "lanes", "." ]

[ "arm", "\"lane out of range\"" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "SITargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "int", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "!=", "1", "&&", "VT", ".", "getScalarType", "(", ")", ".", "bitsLE", "(", "MVT", "::", "i16", ")", ")", "return", "VT", ".", "isPow2VectorType", "(", ")", "?", "TypeSplitVector", ":", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "MVT::i16" ]

[]

[ "<s>", "TargetTransformInfo", "X86TargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "X86TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

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

[]

[ "<s>", "static", "tree", "bfin_handle_l2_attribute", "(", "tree", "*", "node", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "ARG_UNUSED", "(", "args", ")", ",", "int", "ARG_UNUSED", "(", "flags", ")", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "*", "node", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "if", "(", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "NULL", "&&", "strcmp", "(", "DECL_SECTION_NAME", "(", "decl", ")", ",", "\".l2.text\"", ")", "!=", "0", ")", "{", "error", "(", "\"section of %q+D conflicts with previous declaration\"", ",", "decl", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "set_decl_section_name", "(", "decl", ",", "\".l2.text\"", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "NULL", "&&", "strcmp", "(", "DECL_SECTION_NAME", "(", "decl", ")", ",", "\".l2.data\"", ")", "!=", "0", ")", "{", "error", "(", "\"section of %q+D conflicts with previous declaration\"", ",", "decl", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "set_decl_section_name", "(", "decl", ",", "\".l2.data\"", ")", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "l2", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "bfin", "\".l2.text\"", "0", "\"section of %q+D conflicts with previous declaration\"", "\".l2.text\"", "\".l2.data\"", "0", "\"section of %q+D conflicts with previous declaration\"", "\".l2.data\"" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"" ]

[]

[ "<s>", "virtual", "ScheduleHazardRecognizer", "*", "CreateTargetHazardRecognizer", "(", ")", "{", "const", "TargetInstrInfo", "*", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "II", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "SPUHazardRecognizer", "(", "*", "II", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "CellSPU", "\"No InstrInfo?\"", "SPU" ]

[]

[ "<s>", "bool", "ARM64InstrInfo", "::", "isGPRCopy", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "ARM64", "::", "GPR32RegClass", ".", "contains", "(", "DstReg", ")", "||", "ARM64", "::", "GPR64RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "ARM64", "::", "ORRXrs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "ARM64", "::", "XZR", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "4", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid ORRrs operands\"", ")", ";", "return", "true", ";", "}", "case", "ARM64", "::", "ADDXri", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "4", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid ADDXri operands\"", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "a", "GPR", "without", "modifying", "bits", "?" ]

[ "ARM64", "ARM64", "0", "ARM64::GPR32RegClass", "ARM64::GPR64RegClass", "ARM64::ORRXrs", "1", "ARM64::XZR", "4", "3", "0", "\"invalid ORRrs operands\"", "ARM64::ADDXri", "2", "0", "4", "3", "0", "\"invalid ADDXri operands\"" ]

[]

[ "<s>", "static", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "dest", "=", "SET_SRC", "(", "PATTERN", "(", "branch", ")", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "1", ")", ";", "return", "INSN_ADDRESSES", "(", "INSN_UID", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "." ]

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

[]

[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "const", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "Address", ",", "Annot", ",", "STI", ",", "O", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "isPseudo", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "II", "(", "MI", ")", ";", "++", "II", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "while", "(", "II", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "II", "->", "isBundledWithPred", "(", ")", ")", "{", "if", "(", "!", "isPseudo", "(", "&", "*", "II", ")", ")", "return", "false", ";", "II", "++", ";", "}", "return", "true", ";", "}", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "TID", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "SchedClass", "=", "TID", ".", "getSchedClass", "(", ")", ";", "const", "InstrStage", "*", "IS", "=", "PST", ".", "getInstrItineraryData", "(", ")", "->", "beginStage", "(", "SchedClass", ")", ";", "unsigned", "FuncUnits", "=", "IS", "->", "getUnits", "(", ")", ";", "return", "!", "FuncUnits", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "pseudo", "instruction", "that", "does", "n't", "correspond", "to", "a", "real", "machine", "instruction", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "createVR", "(", "MachineFunction", "*", "MF", ",", "MVT", "VT", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", ";", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "{", "TRC", "=", "&", "Hexagon", "::", "PredRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "{", "TRC", "=", "&", "Hexagon", "::", "IntRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "{", "TRC", "=", "&", "Hexagon", "::", "DoubleRegsRegClass", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this register class\"", ")", ";", "}", "Register", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "return", "NewReg", ";", "}", "</s>" ]

[ "HexagonInstrInfo", "specifics", "." ]

[ "Hexagon", "Hexagon", "MVT::i1", "Hexagon::PredRegsRegClass", "MVT::i32", "MVT::f32", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "Hexagon::DoubleRegsRegClass", "\"Cannot handle this register class\"" ]

[]

[ "<s>", "bool", "arc_is_jli_call_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "decl", "||", "!", "SYMBOL_REF_FUNCTION_P", "(", "pat", ")", "||", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_always\"", ",", "attrs", ")", ")", "return", "true", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "TARGET_JLI_ALWAYS", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "a", "jli", "call", "should", "be", "generated", "for", "a", "call", "from", "the", "current", "function", "to", "DECL", "." ]

[ "arc", "\"jli_always\"", "\"jli_fixed\"" ]

[]

[ "<s>", "static", "bool", "ix86_macro_fusion_p", "(", ")", "{", "return", "TARGET_FUSE_CMP_AND_BRANCH", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "platform", "supports", "macro-fusion", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "epiphany_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "(", "outer_code", "==", "PLUS", "||", "outer_code", "==", "MINUS", ")", "&&", "SIMM11", "(", "INTVAL", "(", "x", ")", ")", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "if", "(", "IMM16", "(", "INTVAL", "(", "x", ")", ")", ")", "{", "*", "total", "=", "outer_code", "==", "SET", "?", "0", ":", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "(", "epiphany_small16", "(", "x", ")", "?", "0", ":", "1", ")", "+", "(", "outer_code", "==", "SET", "?", "0", ":", "1", ")", ")", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "{", "rtx", "high", ",", "low", ";", "split_double", "(", "x", ",", "&", "high", ",", "&", "low", ")", ";", "*", "total", "=", "COSTS_N_INSNS", "(", "!", "IMM16", "(", "INTVAL", "(", "high", ")", ")", "+", "!", "IMM16", "(", "INTVAL", "(", "low", ")", ")", ")", ";", "return", "true", ";", "}", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "case", "COMPARE", ":", "switch", "(", "mode", ")", "{", "case", "CC_N_NEmode", ":", "case", "CC_C_LTUmode", ":", "case", "CC_C_GTUmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "case", "SET", ":", "{", "rtx", "src", "=", "SET_SRC", "(", "x", ")", ";", "if", "(", "BINARY_P", "(", "src", ")", ")", "*", "total", "=", "0", ";", "return", "false", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "epiphany", "0", "0", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "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", "." ]

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "Mips::fixup_MICROMIPS_PC10_S1", "2", "Mips::fixup_Mips_64", "8", "4", "0", "Mips", "0", "support::little", "Mips", "1", "8", "1", "64", "0", "support::little", "Mips", "1", "8", "0xff" ]

[]

[ "<s>", "static", "bool", "loongarch_classify_address", "(", "struct", "loongarch_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "loongarch_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "if", "(", "loongarch_valid_base_register_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_index_p", "(", "info", ",", "XEXP", "(", "x", ",", "1", ")", ",", "mode", ",", "strict_p", ")", ")", "{", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "true", ";", "}", "if", "(", "loongarch_valid_base_register_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_index_p", "(", "info", ",", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "strict_p", ")", ")", "{", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "true", ";", "}", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "loongarch_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "loongarch", "0", "1", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "rtx", "mcore_function_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "int", "arg_reg", ";", "if", "(", "!", "named", "||", "mode", "==", "VOIDmode", ")", "return", "0", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "arg_reg", "=", "ROUND_REG", "(", "*", "get_cumulative_args", "(", "cum", ")", ",", "mode", ")", ";", "if", "(", "arg_reg", "<", "NPARM_REGS", ")", "return", "handle_structs_in_regs", "(", "mode", ",", "type", ",", "FIRST_PARM_REG", "+", "arg_reg", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "MCore", "the", "first", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", ".", "Any", "arg", "that", "starts", "within", "the", "first", "NPARM_REGS", "words", "is", "at", "least", "partially", "passed", "in", "a", "register", "unless", "its", "data", "type", "forbids", "." ]

[ "mcore", "0", "0", "0" ]

[]

[ "<s>", "bool", "GBZ80FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ">", "0", "||", "(", "MFI", "->", "getNumObjects", "(", ")", ">", "0", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

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

[]

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

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

[ "FISC", "FISC::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "scalar_chain", "::", "convert_insn_common", "(", "rtx_insn", "*", "insn", ")", "{", "for", "(", "df_ref", "ref", "=", "DF_INSN_DEFS", "(", "insn", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "bitmap_bit_p", "(", "defs_conv", ",", "DF_REF_REGNO", "(", "ref", ")", ")", ")", "{", "df_link", "*", "use", ";", "for", "(", "use", "=", "DF_REF_CHAIN", "(", "ref", ")", ";", "use", ";", "use", "=", "use", "->", "next", ")", "if", "(", "NONDEBUG_INSN_P", "(", "DF_REF_INSN", "(", "use", "->", "ref", ")", ")", "&&", "(", "DF_REF_REG_MEM_P", "(", "use", "->", "ref", ")", "||", "!", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "use", "->", "ref", ")", ")", ")", ")", "break", ";", "if", "(", "use", ")", "convert_reg", "(", "insn", ",", "DF_REF_REG", "(", "ref", ")", ",", "*", "defs_map", ".", "get", "(", "regno_reg_rtx", "[", "DF_REF_REGNO", "(", "ref", ")", "]", ")", ")", ";", "else", "if", "(", "MAY_HAVE_DEBUG_BIND_INSNS", ")", "{", "auto_vec", "<", "rtx_insn", "*", ",", "5", ">", "to_reset_debug_insns", ";", "for", "(", "use", "=", "DF_REF_CHAIN", "(", "ref", ")", ";", "use", ";", "use", "=", "use", "->", "next", ")", "if", "(", "DEBUG_INSN_P", "(", "DF_REF_INSN", "(", "use", "->", "ref", ")", ")", ")", "{", "rtx_insn", "*", "debug_insn", "=", "DF_REF_INSN", "(", "use", "->", "ref", ")", ";", "df_link", "*", "def", ";", "for", "(", "def", "=", "DF_REF_CHAIN", "(", "use", "->", "ref", ")", ";", "def", ";", "def", "=", "def", "->", "next", ")", "if", "(", "!", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "def", "->", "ref", ")", ")", ")", "break", ";", "if", "(", "def", ")", "to_reset_debug_insns", ".", "safe_push", "(", "debug_insn", ")", ";", "else", "{", "*", "DF_REF_REAL_LOC", "(", "use", "->", "ref", ")", "=", "*", "defs_map", ".", "get", "(", "regno_reg_rtx", "[", "DF_REF_REGNO", "(", "ref", ")", "]", ")", ";", "df_insn_rescan", "(", "debug_insn", ")", ";", "}", "}", "while", "(", "!", "to_reset_debug_insns", ".", "is_empty", "(", ")", ")", "{", "rtx_insn", "*", "debug_insn", "=", "to_reset_debug_insns", ".", "pop", "(", ")", ";", "INSN_VAR_LOCATION_LOC", "(", "debug_insn", ")", "=", "gen_rtx_UNKNOWN_VAR_LOC", "(", ")", ";", "df_insn_rescan_debug_internal", "(", "debug_insn", ")", ";", "}", "}", "}", "for", "(", "df_ref", "ref", "=", "DF_INSN_USES", "(", "insn", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_LOC", "(", "ref", ")", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", ")", "if", "(", "rtx", "*", "vreg", "=", "defs_map", ".", "get", "(", "regno_reg_rtx", "[", "DF_REF_REGNO", "(", "ref", ")", "]", ")", ")", "{", "rtx", "note", "=", "find_reg_note", "(", "insn", ",", "REG_DEAD", ",", "DF_REF_REG", "(", "ref", ")", ")", ";", "if", "(", "note", ")", "XEXP", "(", "note", ",", "0", ")", "=", "*", "vreg", ";", "*", "DF_REF_REAL_LOC", "(", "ref", ")", "=", "*", "vreg", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "converting", "INSN", "to", "vector", "mode", "." ]

[ "i386", "5", "0" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Imm", ".", "isZero", "(", ")", "||", "Imm", ".", "isNegZero", "(", ")", ")", "return", "true", ";", "if", "(", "!", "Subtarget", ".", "hasVector", "(", ")", ")", "return", "false", ";", "const", "SystemZInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "Subtarget", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "Start", ",", "End", ";", "return", "analyzeFPImm", "(", "Imm", ",", "VT", ".", "getSizeInBits", "(", ")", ",", "Start", ",", "End", ",", "TII", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

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

[]

[ "<s>", "static", "void", "unicosmk_output_default_externs", "(", "FILE", "*", "file", ")", "{", "static", "const", "char", "*", "const", "externs", "[", "]", "=", "{", "\"__T3E_MISMATCH\"", "}", ";", "int", "i", ";", "int", "n", ";", "n", "=", "ARRAY_SIZE", "(", "externs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "fprintf", "(", "file", ",", "\"\\t.extern\\t%s\\n\"", ",", "externs", "[", "i", "]", ")", ";", "}", "</s>" ]

[ "Output", "extern", "declarations", "which", "are", "required", "for", "every", "asm", "file", "." ]

[ "alpha", "\"__T3E_MISMATCH\"", "0", "\"\\t.extern\\t%s\\n\"" ]

[]

[ "<s>", "bool", "SICRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "lowerInterleavedStore", "(", "StoreInst", "*", "SI", ",", "ShuffleVectorInst", "*", "SVI", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "SVI", "->", "getType", "(", ")", "->", "getVectorNumElements", "(", ")", "%", "Factor", "==", "0", "&&", "\"Invalid interleaved store\"", ")", ";", "SmallVector", "<", "unsigned", ",", "4", ">", "Indices", ";", "auto", "Mask", "=", "SVI", "->", "getShuffleMask", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Factor", ";", "i", "++", ")", "Indices", ".", "push_back", "(", "Mask", "[", "i", "]", ")", ";", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", "=", "makeArrayRef", "(", "SVI", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "SI", ")", ";", "X86InterleavedAccessGroup", "Grp", "(", "SI", ",", "Shuffles", ",", "Indices", ",", "Factor", ",", "Subtarget", ",", "Builder", ")", ";", "return", "Grp", ".", "isSupported", "(", ")", "&&", "Grp", ".", "lowerIntoOptimizedSequence", "(", ")", ";", "}", "</s>" ]

[ "Lower", "interleaved", "store", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "X86", "X86", "2", "\"Invalid interleave factor\"", "0", "\"Invalid interleaved store\"", "4", "0", "X86" ]

[]

[ "<s>", "bool", "SICTargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "SICCC", "&", "SICCCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "SICFunctionInfo", "&", "FI", ")", "const", "{", "return", "false", ";", "if", "(", "SICCCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "SIC", "SIC", "SIC", "SIC", "SIC", "SIC" ]

[]

[ "<s>", "void", "MetadataStreamer", "::", "begin", "(", "const", "Module", "&", "Mod", ")", "{", "AMDGPUASI", "=", "getAMDGPUAS", "(", "Mod", ")", ";", "emitVersion", "(", ")", ";", "emitPrintf", "(", "Mod", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

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

[]

[ "<s>", "int", "ARMAsmParser", "::", "tryParseRegister", "(", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "1", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"r13\"", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "\"r14\"", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "\"r15\"", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "\"ip\"", ",", "ARM", "::", "R12", ")", ".", "Case", "(", "\"a1\"", ",", "ARM", "::", "R0", ")", ".", "Case", "(", "\"a2\"", ",", "ARM", "::", "R1", ")", ".", "Case", "(", "\"a3\"", ",", "ARM", "::", "R2", ")", ".", "Case", "(", "\"a4\"", ",", "ARM", "::", "R3", ")", ".", "Case", "(", "\"v1\"", ",", "ARM", "::", "R4", ")", ".", "Case", "(", "\"v2\"", ",", "ARM", "::", "R5", ")", ".", "Case", "(", "\"v3\"", ",", "ARM", "::", "R6", ")", ".", "Case", "(", "\"v4\"", ",", "ARM", "::", "R7", ")", ".", "Case", "(", "\"v5\"", ",", "ARM", "::", "R8", ")", ".", "Case", "(", "\"v6\"", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "\"v7\"", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "\"v8\"", ",", "ARM", "::", "R11", ")", ".", "Case", "(", "\"sb\"", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "\"sl\"", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "\"fp\"", ",", "ARM", "::", "R11", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "!", "RegNum", ")", "{", "StringMap", "<", "unsigned", ">", "::", "const_iterator", "Entry", "=", "RegisterReqs", ".", "find", "(", "lowerCase", ")", ";", "if", "(", "Entry", "==", "RegisterReqs", ".", "end", "(", ")", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "Entry", "->", "getValue", "(", ")", ";", "}", "if", "(", "!", "hasD32", "(", ")", "&&", "RegNum", ">=", "ARM", "::", "D16", "&&", "RegNum", "<=", "ARM", "::", "D31", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "\"r13\"", "ARM::SP", "\"r14\"", "ARM::LR", "\"r15\"", "ARM::PC", "\"ip\"", "ARM::R12", "\"a1\"", "ARM::R0", "\"a2\"", "ARM::R1", "\"a3\"", "ARM::R2", "\"a4\"", "ARM::R3", "\"v1\"", "ARM::R4", "\"v2\"", "ARM::R5", "\"v3\"", "ARM::R6", "\"v4\"", "ARM::R7", "\"v5\"", "ARM::R8", "\"v6\"", "ARM::R9", "\"v7\"", "ARM::R10", "\"v8\"", "ARM::R11", "\"sb\"", "ARM::R9", "\"sl\"", "ARM::R10", "\"fp\"", "ARM::R11", "0", "1", "ARM::D16", "ARM::D31", "1" ]

[]

[ "<s>", "static", "bool", "mips_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_SIBCALLS", ")", "return", "false", ";", "if", "(", "mips_interrupt_type_p", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "return", "false", ";", "if", "(", "decl", "&&", "const_call_insn_operand", "(", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ",", "VOIDmode", ")", "&&", "mips_call_may_need_jalx_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "decl", "&&", "TARGET_CALL_SAVED_GP", "&&", "!", "TARGET_ABICALLS_PIC0", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "We", "can", "handle", "any", "sibcall", "when", "TARGET_SIBCALLS", "is", "true", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSwiftFastImmShift", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "4", ")", "return", "true", ";", "unsigned", "ShOpVal", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "unsigned", "ShImm", "=", "ARM_AM", "::", "getSORegOffset", "(", "ShOpVal", ")", ";", "if", "(", "(", "ShImm", "==", "1", "&&", "ARM_AM", "::", "getSORegShOp", "(", "ShOpVal", ")", "==", "ARM_AM", "::", "lsr", ")", "||", "(", "(", "ShImm", "==", "1", "||", "ShImm", "==", "2", ")", "&&", "ARM_AM", "::", "getSORegShOp", "(", "ShOpVal", ")", "==", "ARM_AM", "::", "lsl", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "has", "a", "shift", "by", "immediate", "that", "can", "be", "executed", "in", "one", "cycle", "less", "." ]

[ "ARM", "ARM", "4", "3", "ARM_AM::getSORegOffset", "1", "ARM_AM::getSORegShOp", "ARM_AM::lsr", "1", "2", "ARM_AM::getSORegShOp", "ARM_AM::lsl" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "DAG", "->", "MF", ".", "getTarget", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "assert", "(", "(", "!", "llvm", "::", "ForceTopDown", "||", "!", "llvm", "::", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "Hexagon", "\"-misched-topdown incompatible with -misched-bottomup\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "mips_frame_barrier", "(", "void", ")", "{", "emit_clobber", "(", "gen_frame_mem", "(", "BLKmode", ",", "stack_pointer_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "optimisation", "barrier", "for", "accesses", "to", "the", "current", "frame", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "isVirtualSection", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "NVPTX" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "static", "machine_mode", "sparc_cstore_mode", "(", "enum", "insn_code", "icode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "TARGET_ARCH64", "?", "DImode", ":", "SImode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CSTORE_MODE", "." ]

[ "sparc" ]

[]