Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "insn_dependent_p", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "rtx", "tmp", ";", "if", "(", "!", "INSN_P", "(", "x", ")", "||", "!", "INSN_P", "(", "y", ")", ")", "return", "0", ";", "tmp", "=", "PATTERN", "(", "y", ")", ";", "note_stores", "(", "PATTERN", "(", "x", ")", ",", "insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "true", ";", "tmp", "=", "PATTERN", "(", "x", ")", ";", "note_stores", "(", "PATTERN", "(", "y", ")", ",", "insn_dependent_p_1", ",", "&", "tmp", ")", ";", "return", "(", "tmp", "==", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "anything", "in", "insn", "X", "is", "(", "anti", ",", "output", ",", "true", ")", "dependent", "on", "anything", "in", "insn", "Y", "." ]

[ "mt", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "reg_class_t", "rs6000_ira_change_pseudo_allocno_class", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "allocno_class", ",", "reg_class_t", "best_class", ")", "{", "switch", "(", "allocno_class", ")", "{", "case", "GEN_OR_VSX_REGS", ":", "gcc_checking_assert", "(", "best_class", "==", "GEN_OR_VSX_REGS", "||", "best_class", "==", "GEN_OR_FLOAT_REGS", "||", "best_class", "==", "VSX_REGS", "||", "best_class", "==", "ALTIVEC_REGS", "||", "best_class", "==", "FLOAT_REGS", "||", "best_class", "==", "GENERAL_REGS", "||", "best_class", "==", "BASE_REGS", ")", ";", "if", "(", "best_class", "==", "BASE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "TARGET_VSX", "&&", "best_class", "==", "FLOAT_REGS", ")", "return", "VSX_REGS", ";", "return", "best_class", ";", "case", "VSX_REGS", ":", "if", "(", "best_class", "==", "ALTIVEC_REGS", ")", "return", "ALTIVEC_REGS", ";", "default", ":", "break", ";", "}", "return", "allocno_class", ";", "}", "</s>" ]

[ "Implement", "TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS", ".", "The", "register", "allocator", "chooses", "GEN_OR_VSX_REGS", "for", "the", "allocno", "class", "if", "GENERAL_REGS", "and", "VSX_REGS", "cost", "is", "lower", "than", "the", "memory", "cost", ".", "This", "happens", "a", "lot", "when", "TARGET_DIRECT_MOVE", "makes", "the", "register", "move", "cost", "between", "GENERAL_REGS", "and", "VSX_REGS", "low", ".", "It", "might", "seem", "reasonable", "to", "use", "a", "union", "class", ".", "After", "all", ",", "if", "usage", "of", "vsr", "is", "low", "and", "gpr", "high", ",", "it", "might", "make", "sense", "to", "spill", "gpr", "to", "vsr", "rather", "than", "memory", ".", "However", ",", "in", "cases", "where", "register", "pressure", "of", "both", "is", "high", ",", "like", "the", "cactus_adm", "spec", "test", ",", "allowing", "GEN_OR_VSX_REGS", "as", "the", "allocno", "class", "results", "in", "bad", "decisions", "in", "the", "first", "scheduling", "pass", ".", "This", "is", "partly", "due", "to", "an", "allocno", "of", "GEN_OR_VSX_REGS", "wrongly", "contributing", "to", "the", "GENERAL_REGS", "pressure", "class", ",", "which", "gives", "too", "high", "a", "pressure", "for", "GENERAL_REGS", "and", "too", "low", "for", "VSX_REGS", ".", "So", ",", "force", "a", "choice", "of", "the", "subclass", "here", ".", "The", "best", "class", "is", "also", "the", "union", "if", "GENERAL_REGS", "and", "VSX_REGS", "have", "the", "same", "cost", ".", "In", "that", "case", "we", "do", "use", "GEN_OR_VSX_REGS", "as", "the", "allocno", "class", ",", "since", "trying", "to", "narrow", "down", "the", "class", "by", "regno", "mode", "is", "prone", "to", "error", ".", "For", "example", ",", "SImode", "is", "allowed", "in", "VSX", "regs", "and", "in", "some", "cases", "(", "eg", ".", "gcc.target/powerpc/p9-xxbr-3.c", "do_bswap32_vect", ")", "it", "would", "be", "wrong", "to", "choose", "an", "allocno", "of", "GENERAL_REGS", "based", "on", "SImode", "." ]

[ "rs6000" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "getInt", "(", "unsigned", "IntId", ",", "MVT", "ResTy", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "SDValue", ",", "4", ">", "IntOps", ";", "IntOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "IntId", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "append_range", "(", "IntOps", ",", "Ops", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "dl", ",", "ResTy", ",", "IntOps", ")", ";", "}", "</s>" ]

[ "Get", "a", "constant", "integer", "value", "." ]

[ "Hexagon", "Hexagon", "4", "MVT::i32", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "static", "rtx", "sparc_legitimize_pic_address", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "&&", "!", "can_use_mov_pic_label_ref", "(", "orig", ")", ")", ")", "{", "bool", "gotdata_op", "=", "false", ";", "rtx", "pic_ref", ",", "address", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "reg", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "if", "(", "flag_pic", "==", "2", ")", "{", "rtx", "temp_reg", "=", "can_create_pseudo_p", "(", ")", "?", "gen_reg_rtx", "(", "Pmode", ")", ":", "reg", ";", "if", "(", "TARGET_ARCH64", ")", "{", "emit_insn", "(", "gen_movdi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movdi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_movsi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "address", "=", "temp_reg", ";", "gotdata_op", "=", "true", ";", "}", "else", "address", "=", "orig", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "if", "(", "gotdata_op", ")", "{", "if", "(", "TARGET_ARCH64", ")", "insn", "=", "emit_insn", "(", "gen_movdi_pic_gotdata_op", "(", "reg", ",", "pic_offset_table_rtx", ",", "address", ",", "orig", ")", ")", ";", "else", "insn", "=", "emit_insn", "(", "gen_movsi_pic_gotdata_op", "(", "reg", ",", "pic_offset_table_rtx", ",", "address", ",", "orig", ")", ")", ";", "}", "else", "{", "pic_ref", "=", "gen_const_mem", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "address", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "pic_ref", ")", ";", "}", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", "&&", "sparc_pic_register_p", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ")", ")", "return", "orig", ";", "if", "(", "!", "reg", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "sparc_legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "reg", ")", ";", "offset", "=", "sparc_legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "base", "==", "reg", "?", "NULL_RTX", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "CONST_INT", ")", "{", "if", "(", "SMALL_INT", "(", "offset", ")", ")", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "else", "if", "(", "can_create_pseudo_p", "(", ")", ")", "offset", "=", "force_reg", "(", "Pmode", ",", "offset", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "orig", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

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

[]

[ "<s>", "static", "void", "mips_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "|=", "SYMBOL_FLAG_LONG_CALL", ";", "}", "}", "</s>" ]

[ "Set", "SYMBOL_REF_FLAGS", "for", "the", "SYMBOL_REF", "inside", "RTL", ",", "which", "belongs", "to", "DECL", ".", "FIRST", "is", "true", "if", "this", "is", "the", "first", "time", "handling", "this", "decl", "." ]

[ "mips", "\"long_call\"", "0" ]

[]

[ "<s>", "static", "inline", "int", "atomic_alloc", "(", "unsigned", "int", "*", "mask", ")", "{", "unsigned", "int", "old", "=", "*", "mask", ",", "ret", ",", "new", ";", "while", "(", "1", ")", "{", "if", "(", "old", "==", "0", ")", "return", "-", "1", ";", "ret", "=", "old", "&", "-", "old", ";", "new", "=", "old", "&", "~", "ret", ";", "new", "=", "__sync_val_compare_and_swap", "(", "mask", ",", "old", ",", "new", ")", ";", "if", "(", "old", "==", "new", ")", "break", ";", "old", "=", "new", ";", "}", "return", "__builtin_ffs", "(", "ret", ")", "-", "1", ";", "}", "</s>" ]

[ "MASK", "is", "a", "bitmap", "describing", "the", "allocation", "state", "of", "emergency", "buffers", ",", "with", "bit", "set", "indicating", "free", ".", "Return", ">", "=", "0", "if", "allocation", "is", "successful", ";", "<", "0", "if", "failure", "." ]

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

[]

[ "<s>", "static", "bool", "loongarch_pass_aggregate_in_fpr_and_gpr_p", "(", "const_tree", "type", ",", "loongarch_aggregate_field", "fields", "[", "2", "]", ")", "{", "unsigned", "num_int", "=", "0", ",", "num_float", "=", "0", ";", "int", "n", "=", "loongarch_flatten_aggregate_argument", "(", "type", ",", "fields", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "num_float", "+=", "SCALAR_FLOAT_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ";", "num_int", "+=", "INTEGRAL_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ";", "}", "return", "num_int", "==", "1", "&&", "num_float", "==", "1", ";", "}", "</s>" ]

[ "See", "whether", "TYPE", "is", "a", "record", "whose", "fields", "should", "be", "returned", "in", "one", "floating-point", "register", "and", "one", "integer", "register", ".", "If", "so", ",", "populate", "FIELDS", "accordingly", "." ]

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

[]

[ "<s>", "static", "bool", "v850_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "4", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "4", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "v850", "4", "4" ]

[]

[ "<s>", "static", "void", "move_to_end_of_ready", "(", "rtx_insn", "*", "*", "ready", ",", "int", "pos", ",", "int", "lastpos", ")", "{", "rtx_insn", "*", "tmp", ";", "int", "i", ";", "tmp", "=", "ready", "[", "pos", "]", ";", "for", "(", "i", "=", "pos", ";", "i", "<", "lastpos", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "1", "]", ";", "ready", "[", "lastpos", "]", "=", "tmp", ";", "}", "</s>" ]

[ "Move", "instruction", "at", "POS", "to", "the", "end", "of", "the", "READY", "list", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "stackProbeFunctionModifiesSP", "(", ")", "const", "{", "return", "STI", ".", "isOSWindows", "(", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ";", "}", "</s>" ]

[ "Does", "the", "stack", "probe", "function", "call", "return", "with", "a", "modified", "stack", "pointer", "?" ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isCopyInstr", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Src", ",", "const", "MachineOperand", "*", "&", "Dest", ")", "const", "{", "if", "(", "!", "MI", ".", "isMoveReg", "(", ")", "||", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VORRq", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

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

[]

[ "<s>", "int", "ia64_produce_address_p", "(", "rtx", "insn", ")", "{", "return", "insn", "->", "call", ";", "}", "</s>" ]

[ "The", "following", "function", "returns", "TRUE", "if", "INSN", "produces", "address", "for", "a", "load/store", "insn", ".", "We", "will", "place", "such", "insns", "into", "M", "slot", "because", "it", "decreases", "its", "latency", "time", "." ]

[ "ia64" ]

[]

[ "<s>", "enum", "rtx_code", "arm_canonicalize_comparison", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "*", "op1", ")", "{", "unsigned", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "*", "op1", ")", ";", "unsigned", "HOST_WIDE_INT", "maxval", ";", "maxval", "=", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", ")", "<<", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "1", ")", ")", "-", "1", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "return", "code", ";", "case", "GT", ":", "case", "LE", ":", "if", "(", "i", "!=", "maxval", "&&", "(", "const_ok_for_arm", "(", "i", "+", "1", ")", "||", "const_ok_for_arm", "(", "-", "(", "i", "+", "1", ")", ")", ")", ")", "{", "*", "op1", "=", "GEN_INT", "(", "i", "+", "1", ")", ";", "return", "code", "==", "GT", "?", "GE", ":", "LT", ";", "}", "break", ";", "case", "GE", ":", "case", "LT", ":", "if", "(", "i", "!=", "~", "maxval", "&&", "(", "const_ok_for_arm", "(", "i", "-", "1", ")", "||", "const_ok_for_arm", "(", "-", "(", "i", "-", "1", ")", ")", ")", ")", "{", "*", "op1", "=", "GEN_INT", "(", "i", "-", "1", ")", ";", "return", "code", "==", "GE", "?", "GT", ":", "LE", ";", "}", "break", ";", "case", "GTU", ":", "case", "LEU", ":", "if", "(", "i", "!=", "~", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "0", ")", "&&", "(", "const_ok_for_arm", "(", "i", "+", "1", ")", "||", "const_ok_for_arm", "(", "-", "(", "i", "+", "1", ")", ")", ")", ")", "{", "*", "op1", "=", "GEN_INT", "(", "i", "+", "1", ")", ";", "return", "code", "==", "GTU", "?", "GEU", ":", "LTU", ";", "}", "break", ";", "case", "GEU", ":", "case", "LTU", ":", "if", "(", "i", "!=", "0", "&&", "(", "const_ok_for_arm", "(", "i", "-", "1", ")", "||", "const_ok_for_arm", "(", "-", "(", "i", "-", "1", ")", ")", ")", ")", "{", "*", "op1", "=", "GEN_INT", "(", "i", "-", "1", ")", ";", "return", "code", "==", "GEU", "?", "GTU", ":", "LEU", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "code", ";", "}", "</s>" ]

[ "Canonicalize", "a", "comparison", "so", "that", "we", "are", "more", "likely", "to", "recognize", "it", ".", "This", "can", "be", "done", "for", "a", "few", "constant", "compares", ",", "where", "we", "can", "make", "the", "immediate", "value", "easier", "to", "load", "." ]

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "MINA32TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "llvm_unreachable", "(", "\"LowerOperation() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "\"LowerOperation() unimplemented\"" ]

[]

[ "<s>", "static", "int", "s390_issue_rate", "(", "void", ")", "{", "switch", "(", "s390_tune", ")", "{", "case", "PROCESSOR_2084_Z990", ":", "case", "PROCESSOR_2094_Z9_109", ":", "case", "PROCESSOR_2094_Z9_EC", ":", "case", "PROCESSOR_2817_Z196", ":", "return", "3", ";", "case", "PROCESSOR_2097_Z10", ":", "return", "2", ";", "case", "PROCESSOR_9672_G5", ":", "case", "PROCESSOR_9672_G6", ":", "case", "PROCESSOR_2064_Z900", ":", "case", "PROCESSOR_2827_ZEC12", ":", "case", "PROCESSOR_2964_Z13", ":", "case", "PROCESSOR_3906_Z14", ":", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "The", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "s390", "3", "2", "1" ]

[]

[ "<s>", "const", "char", "*", "output_call_mem", "(", "rtx", "*", "operands", ")", "{", "gcc_assert", "(", "!", "arm_arch5", ")", ";", "if", "(", "TARGET_INTERWORK", ")", "{", "output_asm_insn", "(", "\"ldr%?\\t%|ip, %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bx%?\\t%|ip\"", ",", "operands", ")", ";", "}", "else", "if", "(", "regno_use_in", "(", "LR_REGNUM", ",", "operands", "[", "0", "]", ")", ")", "{", "output_asm_insn", "(", "\"ldr%?\\t%|ip, %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "if", "(", "arm_arch4t", ")", "output_asm_insn", "(", "\"bx%?\\t%|ip\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov%?\\t%|pc, %|ip\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr%?\\t%|pc, %0\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "'call", "'", "insn", "that", "is", "a", "reference", "in", "memory", ".", "This", "is", "disabled", "for", "ARMv5", "and", "we", "prefer", "a", "blx", "instead", "because", "otherwise", "there", "'s", "a", "significant", "performance", "overhead", "." ]

[ "arm", "\"ldr%?\\t%|ip, %0\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%|ip\"", "0", "\"ldr%?\\t%|ip, %0\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%|ip\"", "\"mov%?\\t%|pc, %|ip\"", "\"mov%?\\t%|lr, %|pc\"", "\"ldr%?\\t%|pc, %0\"", "\"\"" ]

[]

[ "<s>", "static", "bool", "pru_hard_regno_scratch_ok", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "&&", "(", "IN_RANGE", "(", "regno", ",", "HARD_FRAME_POINTER_REGNUM", ",", "HARD_FRAME_POINTER_REGNUM", "+", "3", ")", "||", "IN_RANGE", "(", "regno", ",", "FRAME_POINTER_REGNUM", ",", "FRAME_POINTER_REGNUM", "+", "3", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_HARD_REGNO_SCRATCH_OK", "'", ".", "Returns", "true", "if", "REGNO", "is", "safe", "to", "be", "allocated", "as", "a", "scratch", "register", "(", "for", "a", "define_peephole2", ")", "in", "the", "current", "function", "." ]

[ "pru", "3", "3" ]

[]

[ "<s>", "void", "AMDGPUTargetMachine", "::", "registerDefaultAliasAnalyses", "(", "AAManager", "&", "AAM", ")", "{", "AAM", ".", "registerFunctionAnalysis", "<", "AMDGPUAA", ">", "(", ")", ";", "}", "</s>" ]

[ "Allow", "the", "target", "to", "register", "alias", "analyses", "with", "the", "AAManager", "for", "use", "with", "the", "new", "pass", "manager", "." ]

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

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "NumBytes", "-", "1", ")", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "int", "xt_true_regnum", "(", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "HARD_REGISTER_P", "(", "x", ")", "&&", "reg_renumber", "&&", "(", "lra_in_progress", "||", "reg_renumber", "[", "REGNO", "(", "x", ")", "]", ">=", "0", ")", ")", "return", "reg_renumber", "[", "REGNO", "(", "x", ")", "]", ";", "return", "REGNO", "(", "x", ")", ";", "}", "if", "(", "SUBREG_P", "(", "x", ")", ")", "{", "int", "base", "=", "xt_true_regnum", "(", "SUBREG_REG", "(", "x", ")", ")", ";", "if", "(", "base", ">=", "0", "&&", "HARD_REGISTER_NUM_P", "(", "base", ")", ")", "{", "struct", "subreg_info", "info", ";", "subreg_get_info", "(", "lra_in_progress", "?", "(", "unsigned", ")", "base", ":", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "&", "info", ")", ";", "if", "(", "info", ".", "representable_p", ")", "return", "base", "+", "info", ".", "offset", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "This", "is", "just", "like", "the", "standard", "true_regnum", "(", ")", "function", "except", "that", "it", "works", "even", "when", "reg_renumber", "is", "not", "initialized", "." ]

[ "xtensa", "0", "0", "1" ]

[]

[ "<s>", "bool", "SIPreEmitPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "continue", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_CBRANCH_VCCZ", ":", "case", "AMDGPU", "::", "S_CBRANCH_VCCNZ", ":", "Changed", "|=", "optimizeVccBranch", "(", "MI", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_CBRANCH_VCCZ", "AMDGPU::S_CBRANCH_VCCNZ" ]

[]

[ "<s>", "void", "prepare", "(", ")", "{", "assert", "(", "RS", "&&", "\"Cannot spill SGPR to memory without RegScavenger\"", ")", ";", "TmpVGPR", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MI", ",", "0", ",", "false", ")", ";", "TmpVGPRIndex", "=", "MFI", ".", "getScavengeFI", "(", "MF", ".", "getFrameInfo", "(", ")", ",", "TRI", ")", ";", "if", "(", "TmpVGPR", ")", "{", "TmpVGPRLive", "=", "false", ";", "}", "else", "{", "TmpVGPR", "=", "AMDGPU", "::", "VGPR0", ";", "TmpVGPRLive", "=", "true", ";", "}", "assert", "(", "!", "SavedExecReg", "&&", "\"Exec is already saved, refuse to save again\"", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "IsWave32", "?", "AMDGPU", "::", "SGPR_32RegClass", ":", "AMDGPU", "::", "SGPR_64RegClass", ";", "RS", "->", "setRegUsed", "(", "SuperReg", ")", ";", "SavedExecReg", "=", "RS", "->", "scavengeRegister", "(", "&", "RC", ",", "MI", ",", "0", ",", "false", ")", ";", "int64_t", "VGPRLanes", "=", "getPerVGPRData", "(", ")", ".", "VGPRLanes", ";", "if", "(", "SavedExecReg", ")", "{", "RS", "->", "setRegUsed", "(", "SavedExecReg", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "SavedExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "auto", "I", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "ExecReg", ")", ".", "addImm", "(", "VGPRLanes", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "else", "{", "if", "(", "TmpVGPRLive", ")", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ",", "false", ")", ";", "auto", "I", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "NotOpc", ")", ",", "ExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "I", "->", "getOperand", "(", "2", ")", ".", "setIsDead", "(", "true", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "\"Cannot spill SGPR to memory without RegScavenger\"", "AMDGPU::VGPR_32RegClass", "0", "AMDGPU::VGPR0", "\"Exec is already saved, refuse to save again\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_64RegClass", "0", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "int", "nios2_compute_frame_layout", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "unsigned", "int", "save_mask", "=", "0", ";", "int", "total_size", ";", "int", "var_size", ";", "int", "out_args_size", ";", "int", "save_reg_size", ";", "int", "callee_save_reg_size", ";", "if", "(", "cfun", "->", "machine", "->", "initialized", ")", "return", "cfun", "->", "machine", "->", "total_size", ";", "save_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_GP_REG", ";", "regno", "++", ")", "if", "(", "prologue_saved_reg_p", "(", "regno", ")", ")", "{", "save_mask", "|=", "1", "<<", "regno", ";", "save_reg_size", "+=", "4", ";", "}", "if", "(", "TARGET_HAS_CDX", "&&", "save_reg_size", "!=", "0", ")", "{", "if", "(", "(", "save_mask", "&", "(", "1", "<<", "RA_REGNO", ")", ")", "==", "0", ")", "{", "save_mask", "|=", "1", "<<", "RA_REGNO", ";", "save_reg_size", "+=", "4", ";", "}", "for", "(", "regno", "=", "23", ";", "regno", ">=", "16", ";", "regno", "--", ")", "if", "(", "(", "save_mask", "&", "(", "1", "<<", "regno", ")", ")", "!=", "0", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "regno", "-", "1", ";", "i", ">=", "16", ";", "i", "--", ")", "if", "(", "(", "save_mask", "&", "(", "1", "<<", "i", ")", ")", "==", "0", ")", "{", "save_mask", "|=", "1", "<<", "i", ";", "save_reg_size", "+=", "4", ";", "}", "break", ";", "}", "}", "callee_save_reg_size", "=", "save_reg_size", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "i", ";", "unsigned", "r", ";", "for", "(", "i", "=", "0", ";", "(", "r", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "if", "(", "!", "(", "save_mask", "&", "(", "1", "<<", "r", ")", ")", ")", "{", "save_mask", "|=", "1", "<<", "r", ";", "save_reg_size", "+=", "4", ";", "}", "}", "cfun", "->", "machine", "->", "fp_save_offset", "=", "0", ";", "if", "(", "save_mask", "&", "(", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "int", "fp_save_offset", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "HARD_FRAME_POINTER_REGNUM", ";", "regno", "++", ")", "if", "(", "save_mask", "&", "(", "1", "<<", "regno", ")", ")", "fp_save_offset", "+=", "4", ";", "cfun", "->", "machine", "->", "fp_save_offset", "=", "fp_save_offset", ";", "}", "var_size", "=", "NIOS2_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "out_args_size", "=", "NIOS2_STACK_ALIGN", "(", "crtl", "->", "outgoing_args_size", ")", ";", "total_size", "=", "var_size", "+", "out_args_size", ";", "save_reg_size", "=", "NIOS2_STACK_ALIGN", "(", "save_reg_size", ")", ";", "total_size", "+=", "save_reg_size", ";", "total_size", "+=", "NIOS2_STACK_ALIGN", "(", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "cfun", "->", "machine", "->", "save_mask", "=", "save_mask", ";", "cfun", "->", "machine", "->", "total_size", "=", "total_size", ";", "cfun", "->", "machine", "->", "var_size", "=", "var_size", ";", "cfun", "->", "machine", "->", "args_size", "=", "out_args_size", ";", "cfun", "->", "machine", "->", "save_reg_size", "=", "save_reg_size", ";", "cfun", "->", "machine", "->", "callee_save_reg_size", "=", "callee_save_reg_size", ";", "cfun", "->", "machine", "->", "initialized", "=", "reload_completed", ";", "cfun", "->", "machine", "->", "save_regs_offset", "=", "out_args_size", "+", "var_size", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", "." ]

[ "nios2", "0", "0", "0", "1", "4", "0", "1", "0", "1", "4", "23", "16", "1", "0", "1", "16", "1", "0", "1", "4", "0", "1", "1", "4", "0", "1", "0", "0", "1", "4" ]

[]

[ "<s>", "const", "char", "*", "AArch64TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "AArch64ISD", "::", "BR_CC", ":", "return", "\"AArch64ISD::BR_CC\"", ";", "case", "AArch64ISD", "::", "Call", ":", "return", "\"AArch64ISD::Call\"", ";", "case", "AArch64ISD", "::", "FPMOV", ":", "return", "\"AArch64ISD::FPMOV\"", ";", "case", "AArch64ISD", "::", "GOTLoad", ":", "return", "\"AArch64ISD::GOTLoad\"", ";", "case", "AArch64ISD", "::", "BFI", ":", "return", "\"AArch64ISD::BFI\"", ";", "case", "AArch64ISD", "::", "EXTR", ":", "return", "\"AArch64ISD::EXTR\"", ";", "case", "AArch64ISD", "::", "Ret", ":", "return", "\"AArch64ISD::Ret\"", ";", "case", "AArch64ISD", "::", "SBFX", ":", "return", "\"AArch64ISD::SBFX\"", ";", "case", "AArch64ISD", "::", "SELECT_CC", ":", "return", "\"AArch64ISD::SELECT_CC\"", ";", "case", "AArch64ISD", "::", "SETCC", ":", "return", "\"AArch64ISD::SETCC\"", ";", "case", "AArch64ISD", "::", "TC_RETURN", ":", "return", "\"AArch64ISD::TC_RETURN\"", ";", "case", "AArch64ISD", "::", "THREAD_POINTER", ":", "return", "\"AArch64ISD::THREAD_POINTER\"", ";", "case", "AArch64ISD", "::", "TLSDESCCALL", ":", "return", "\"AArch64ISD::TLSDESCCALL\"", ";", "case", "AArch64ISD", "::", "WrapperLarge", ":", "return", "\"AArch64ISD::WrapperLarge\"", ";", "case", "AArch64ISD", "::", "WrapperSmall", ":", "return", "\"AArch64ISD::WrapperSmall\"", ";", "case", "AArch64ISD", "::", "NEON_BSL", ":", "return", "\"AArch64ISD::NEON_BSL\"", ";", "case", "AArch64ISD", "::", "NEON_MOVIMM", ":", "return", "\"AArch64ISD::NEON_MOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_MVNIMM", ":", "return", "\"AArch64ISD::NEON_MVNIMM\"", ";", "case", "AArch64ISD", "::", "NEON_FMOVIMM", ":", "return", "\"AArch64ISD::NEON_FMOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_CMP", ":", "return", "\"AArch64ISD::NEON_CMP\"", ";", "case", "AArch64ISD", "::", "NEON_CMPZ", ":", "return", "\"AArch64ISD::NEON_CMPZ\"", ";", "case", "AArch64ISD", "::", "NEON_TST", ":", "return", "\"AArch64ISD::NEON_TST\"", ";", "case", "AArch64ISD", "::", "NEON_QSHLs", ":", "return", "\"AArch64ISD::NEON_QSHLs\"", ";", "case", "AArch64ISD", "::", "NEON_QSHLu", ":", "return", "\"AArch64ISD::NEON_QSHLu\"", ";", "case", "AArch64ISD", "::", "NEON_VDUP", ":", "return", "\"AArch64ISD::NEON_VDUP\"", ";", "case", "AArch64ISD", "::", "NEON_VDUPLANE", ":", "return", "\"AArch64ISD::NEON_VDUPLANE\"", ";", "case", "AArch64ISD", "::", "NEON_LD1_UPD", ":", "return", "\"AArch64ISD::NEON_LD1_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_LD2_UPD", ":", "return", "\"AArch64ISD::NEON_LD2_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_LD3_UPD", ":", "return", "\"AArch64ISD::NEON_LD3_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_LD4_UPD", ":", "return", "\"AArch64ISD::NEON_LD4_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_ST1_UPD", ":", "return", "\"AArch64ISD::NEON_ST1_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_ST2_UPD", ":", "return", "\"AArch64ISD::NEON_ST2_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_ST3_UPD", ":", "return", "\"AArch64ISD::NEON_ST3_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_ST4_UPD", ":", "return", "\"AArch64ISD::NEON_ST4_UPD\"", ";", "case", "AArch64ISD", "::", "NEON_VEXTRACT", ":", "return", "\"AArch64ISD::NEON_VEXTRACT\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64ISD::BR_CC", "\"AArch64ISD::BR_CC\"", "AArch64ISD::Call", "\"AArch64ISD::Call\"", "AArch64ISD::FPMOV", "\"AArch64ISD::FPMOV\"", "AArch64ISD::GOTLoad", "\"AArch64ISD::GOTLoad\"", "AArch64ISD::BFI", "\"AArch64ISD::BFI\"", "AArch64ISD::EXTR", "\"AArch64ISD::EXTR\"", "AArch64ISD::Ret", "\"AArch64ISD::Ret\"", "AArch64ISD::SBFX", "\"AArch64ISD::SBFX\"", "AArch64ISD::SELECT_CC", "\"AArch64ISD::SELECT_CC\"", "AArch64ISD::SETCC", "\"AArch64ISD::SETCC\"", "AArch64ISD::TC_RETURN", "\"AArch64ISD::TC_RETURN\"", "AArch64ISD::THREAD_POINTER", "\"AArch64ISD::THREAD_POINTER\"", "AArch64ISD::TLSDESCCALL", "\"AArch64ISD::TLSDESCCALL\"", "AArch64ISD::WrapperLarge", "\"AArch64ISD::WrapperLarge\"", "AArch64ISD::WrapperSmall", "\"AArch64ISD::WrapperSmall\"", "AArch64ISD::NEON_BSL", "\"AArch64ISD::NEON_BSL\"", "AArch64ISD::NEON_MOVIMM", "\"AArch64ISD::NEON_MOVIMM\"", "AArch64ISD::NEON_MVNIMM", "\"AArch64ISD::NEON_MVNIMM\"", "AArch64ISD::NEON_FMOVIMM", "\"AArch64ISD::NEON_FMOVIMM\"", "AArch64ISD::NEON_CMP", "\"AArch64ISD::NEON_CMP\"", "AArch64ISD::NEON_CMPZ", "\"AArch64ISD::NEON_CMPZ\"", "AArch64ISD::NEON_TST", "\"AArch64ISD::NEON_TST\"", "AArch64ISD::NEON_QSHLs", "\"AArch64ISD::NEON_QSHLs\"", "AArch64ISD::NEON_QSHLu", "\"AArch64ISD::NEON_QSHLu\"", "AArch64ISD::NEON_VDUP", "\"AArch64ISD::NEON_VDUP\"", "AArch64ISD::NEON_VDUPLANE", "\"AArch64ISD::NEON_VDUPLANE\"", "AArch64ISD::NEON_LD1_UPD", "\"AArch64ISD::NEON_LD1_UPD\"", "AArch64ISD::NEON_LD2_UPD", "\"AArch64ISD::NEON_LD2_UPD\"", "AArch64ISD::NEON_LD3_UPD", "\"AArch64ISD::NEON_LD3_UPD\"", "AArch64ISD::NEON_LD4_UPD", "\"AArch64ISD::NEON_LD4_UPD\"", "AArch64ISD::NEON_ST1_UPD", "\"AArch64ISD::NEON_ST1_UPD\"", "AArch64ISD::NEON_ST2_UPD", "\"AArch64ISD::NEON_ST2_UPD\"", "AArch64ISD::NEON_ST3_UPD", "\"AArch64ISD::NEON_ST3_UPD\"", "AArch64ISD::NEON_ST4_UPD", "\"AArch64ISD::NEON_ST4_UPD\"", "AArch64ISD::NEON_VEXTRACT", "\"AArch64ISD::NEON_VEXTRACT\"" ]

[]

[ "<s>", "bool", "HexagonRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "HexagonFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "if", "(", "EnableDPPCombine", ")", "addPass", "(", "&", "GCNDPPCombineID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "&", "SILoadStoreOptimizerID", ")", ";", "if", "(", "EnableSDWAPeephole", ")", "{", "addPass", "(", "&", "SIPeepholeSDWAID", ")", ";", "addPass", "(", "&", "EarlyMachineLICMID", ")", ";", "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "void", "vms_c_register_includes", "(", "const", "char", "*", "sysroot", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "iprefix", "ATTRIBUTE_UNUSED", ",", "int", "stdinc", "ATTRIBUTE_UNUSED", ")", "{", "}", "</s>" ]

[ "Find", "include", "modules", "in", "the", "include", "path", "." ]

[ "vms" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printOffset", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "uint16_t", "Imm", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "!=", "0", ")", "{", "O", "<<", "\" offset:\"", ";", "printU16ImmDecOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "just", "convenient", "handler", "for", "printing", "offsets", "." ]

[ "AMDGPU", "AMDGPU", "0", "\" offset:\"" ]

[]

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

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

[ "XCore", "XCore" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "or1k_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

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

[ "or1k" ]

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicOps", "(", ")", "const", "override", "{", "return", "ISD", "::", "ANY_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "operations", "are", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "SystemZ", "ISD::NodeType", "ISD::ANY_EXTEND" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"m0\"", ",", "AMDGPU", "::", "M0", ")", ".", "Case", "(", "\"exec\"", ",", "AMDGPU", "::", "EXEC", ")", ".", "Case", "(", "\"exec_lo\"", ",", "AMDGPU", "::", "EXEC_LO", ")", ".", "Case", "(", "\"exec_hi\"", ",", "AMDGPU", "::", "EXEC_HI", ")", ".", "Case", "(", "\"flat_scratch\"", ",", "AMDGPU", "::", "FLAT_SCR", ")", ".", "Case", "(", "\"flat_scratch_lo\"", ",", "AMDGPU", "::", "FLAT_SCR_LO", ")", ".", "Case", "(", "\"flat_scratch_hi\"", ",", "AMDGPU", "::", "FLAT_SCR_HI", ")", ".", "Default", "(", "AMDGPU", "::", "NoRegister", ")", ";", "if", "(", "Reg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", "&&", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "regsOverlap", "(", "Reg", ",", "AMDGPU", "::", "FLAT_SCR", ")", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\" for subtarget.\"", ")", ")", ";", "}", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "M0", ":", "case", "AMDGPU", "::", "EXEC_LO", ":", "case", "AMDGPU", "::", "EXEC_HI", ":", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "return", "Reg", ";", "break", ";", "case", "AMDGPU", "::", "EXEC", ":", "case", "AMDGPU", "::", "FLAT_SCR", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "Reg", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"missing register type checking\"", ")", ";", "}", "report_fatal_error", "(", "Twine", "(", "\"invalid type for register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "AMDGPU", "SI", "\"m0\"", "AMDGPU::M0", "\"exec\"", "AMDGPU::EXEC", "\"exec_lo\"", "AMDGPU::EXEC_LO", "\"exec_hi\"", "AMDGPU::EXEC_HI", "\"flat_scratch\"", "AMDGPU::FLAT_SCR", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_hi\"", "AMDGPU::FLAT_SCR_HI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "\"invalid register name \\\"\"", "\"\\\".\"", "AMDGPU", "AMDGPU::FLAT_SCR", "\"invalid register \\\"\"", "\"\\\" for subtarget.\"", "AMDGPU::M0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::FLAT_SCR_LO", "AMDGPU::FLAT_SCR_HI", "32", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "64", "\"missing register type checking\"", "\"invalid type for register \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "void", "split_double_move", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "bool", "swap", "=", "false", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", "swap", "=", "true", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", ")", "{", "rtx", "op", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", "&&", "REGNO", "(", "op", ")", "==", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "swap", "=", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "{", "rtx", "x", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "y", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", "==", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "swap", "=", "true", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "REG", "&&", "REGNO", "(", "y", ")", "==", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "swap", "=", "true", ";", "}", "}", "if", "(", "swap", ")", "{", "operands", "[", "2", "]", "=", "operand_subword", "(", "operands", "[", "0", "]", ",", "1", ",", "1", ",", "mode", ")", ";", "operands", "[", "3", "]", "=", "operand_subword", "(", "operands", "[", "1", "]", ",", "1", ",", "1", ",", "mode", ")", ";", "operands", "[", "4", "]", "=", "operand_subword", "(", "operands", "[", "0", "]", ",", "0", ",", "1", ",", "mode", ")", ";", "operands", "[", "5", "]", "=", "operand_subword", "(", "operands", "[", "1", "]", ",", "0", ",", "1", ",", "mode", ")", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "operand_subword", "(", "operands", "[", "0", "]", ",", "0", ",", "1", ",", "mode", ")", ";", "operands", "[", "3", "]", "=", "operand_subword", "(", "operands", "[", "1", "]", ",", "0", ",", "1", ",", "mode", ")", ";", "operands", "[", "4", "]", "=", "operand_subword", "(", "operands", "[", "0", "]", ",", "1", ",", "1", ",", "mode", ")", ";", "operands", "[", "5", "]", "=", "operand_subword", "(", "operands", "[", "1", "]", ",", "1", ",", "1", ",", "mode", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "double", "move", "of", "OPERANDS", "in", "MODE", "." ]

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

[]

[ "<s>", "bool", "SILowerLiteralConstantsPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "S_MOV_IMM_I32", ":", "case", "AMDGPU", "::", "S_MOV_IMM_I64", ":", "case", "AMDGPU", "::", "V_MOV_IMM_F32", ":", "case", "AMDGPU", "::", "V_MOV_IMM_I32", ":", "{", "unsigned", "MovOpcode", ";", "unsigned", "LoadLiteralOpcode", ";", "MachineOperand", "LiteralOp", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "MovOpcode", "=", "AMDGPU", "::", "V_MOV_B32_e32", ";", "}", "else", "{", "MovOpcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "}", "if", "(", "LiteralOp", ".", "isImm", "(", ")", ")", "{", "LoadLiteralOpcode", "=", "AMDGPU", "::", "SI_LOAD_LITERAL_I32", ";", "}", "else", "{", "LoadLiteralOpcode", "=", "AMDGPU", "::", "SI_LOAD_LITERAL_F32", ";", "}", "MIBundleBuilder", "Bundle", "(", "MBB", ",", "I", ")", ";", "Bundle", ".", "append", "(", "BuildMI", "(", "MF", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "MovOpcode", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "AMDGPU", "::", "SI_LITERAL_CONSTANT", ")", ")", ".", "append", "(", "BuildMI", "(", "MF", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "LoadLiteralOpcode", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ")", ";", "llvm", "::", "finalizeBundle", "(", "MBB", ",", "Bundle", ".", "begin", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI", "1", "0", "SI", "SI", "0", "SI", "1" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "neon_make_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "target", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_const", "=", "0", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL", "&&", "neon_immediate_valid_for_move", "(", "const_vec", ",", "mode", ",", "NULL", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "(", "target", "=", "neon_vdup_constant", "(", "vals", ")", ")", "!=", "NULL_RTX", ")", "return", "target", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]

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

[]

[ "<s>", "bool", "aarch64_float_const_representable_p", "(", "rtx", "x", ")", "{", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "int", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mask", ";", "REAL_VALUE_TYPE", "r", ",", "m", ";", "bool", "fail", ";", "if", "(", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "||", "(", "GET_MODE", "(", "x", ")", "==", "HFmode", "&&", "!", "TARGET_FP_F16INST", ")", ")", "return", "false", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "false", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "if", "(", "w", ".", "ulow", "(", ")", "!=", "0", ")", "return", "false", ";", "mantissa", "=", "w", ".", "elt", "(", "1", ")", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "false", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "false", ";", "mantissa", "&=", "~", "(", "1", "<<", "4", ")", ";", "gcc_assert", "(", "mantissa", "<=", "15", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "return", "(", "exponent", ">=", "0", "&&", "exponent", "<=", "7", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "X", "can", "be", "represented", "by", "a", "quarter-precision", "floating", "point", "immediate", "operand", "X", ".", "Note", ",", "we", "can", "not", "represent", "0.0", "." ]

[ "aarch64", "2", "1", "2", "0", "1", "1", "5", "1", "0", "5", "0", "1", "4", "15", "5", "0", "7" ]

[]

[ "<s>", "std", "::", "string", "BTFTypeStruct", "::", "getName", "(", ")", "{", "return", "STy", "->", "getName", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "BPF" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "spillsCR", "(", "MF", ")", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "224", "PPC", "0", "PPC" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "XCore", "XCore", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "F", "(", "rtx_insn", "*", "x", ")", "{", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "We", "use", "this", "to", "wrap", "all", "emitted", "insns", "in", "the", "prologue", ",", "so", "they", "get", "the", "``", "frame-related", "''", "(", "/f", ")", "flag", "set", "." ]

[ "mep", "1" ]

[]

[ "<s>", "TargetIRAnalysis", "NVPTXTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", ")", "{", "return", "TargetTransformInfo", "(", "NVPTXTTIImpl", "(", "this", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "GBZ80RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "<=", "1", ")", "return", "CSR_0_1_RegMask", ";", "else", "return", "CSR_2_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "Gen", "=", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", "?", "SIEncodingFamily", "::", "SDWA9", ":", "SIEncodingFamily", "::", "SDWA", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "F16_ZFILL", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SIInstrFlags::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "SIEncodingFamily::SDWA", "SIInstrFlags::F16_ZFILL", "0", "AMDGPU", "SIEncodingFamily::GFX9", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "X86TargetLowering", "::", "findRepresentativeClass", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "TRI", ",", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "break", ";", "case", "MVT", "::", "x86mmx", ":", "RRC", "=", "&", "X86", "::", "VR64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "RRC", "=", "&", "X86", "::", "VR128RegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "X86", "X86", "1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::x86mmx", "X86::VR64RegClass", "MVT::f32", "MVT::f64", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "MVT::v32i8", "MVT::v8i32", "MVT::v4i64", "MVT::v8f32", "MVT::v4f64", "X86::VR128RegClass" ]

[]

[ "<s>", "bool", "rs6000_split_128bit_ok_p", "(", "rtx", "operands", "[", "]", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "!", "gpr_or_gpr_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "if", "(", "quad_load_store_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "128-bit", "move", "needs", "to", "be", "split", "." ]

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "is64BitELFABI", "(", ")", ")", "return", "false", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", ")", "return", "false", ";", "auto", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "if", "(", "!", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "DisableSCO", ")", "return", "false", ";", "const", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "!", "Callee", "||", "Callee", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "const", "Function", "*", "Caller", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "!", "areCallingConvEligibleForTCO_64SVR4", "(", "Caller", "->", "getCallingConv", "(", ")", ",", "CI", "->", "getCallingConv", "(", ")", ")", ")", "return", "false", ";", "return", "getTargetMachine", "(", ")", ".", "shouldAssumeDSOLocal", "(", "*", "Caller", "->", "getParent", "(", ")", ",", "Callee", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "sh_ashlsi_clobbers_t_reg_p", "(", "rtx", "shift_amount", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "shift_amount", ")", ")", ";", "const", "int", "shift_amount_i", "=", "INTVAL", "(", "shift_amount", ")", "&", "31", ";", "if", "(", "shift_amount_i", "==", "31", ")", "return", "true", ";", "return", "(", "ashl_lshr_seq", "[", "shift_amount_i", "]", ".", "clobbers_t", "&", "ASHL_CLOBBERS_T", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "shift", "left", "consisting", "of", "1/2/8/16", "shift", "instructions", "will", "clobber", "the", "T", "bit", "." ]

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

[]

[ "<s>", "void", "setType", "(", "GBSectionType", "T", ")", "{", "Type", "=", "T", ";", "}", "</s>" ]

[ "Set", "the", "low-level", "type", "of", "VReg", "to", "Ty", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "static", "void", "do_load_for_compare", "(", "rtx", "reg", ",", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE", "(", "reg", ")", ")", "{", "case", "DImode", ":", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_zero_extendqidi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhidi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "SImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_bswapsi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendsidi2", "(", "reg", ",", "src", ")", ")", ";", "}", "break", ";", "case", "DImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapdi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movdi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "SImode", ":", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_zero_extendqisi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhisi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "SImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapsi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "DImode", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Figure", "out", "the", "correct", "instructions", "to", "generate", "to", "load", "data", "for", "block", "compare", ".", "MODE", "is", "used", "for", "the", "read", "from", "memory", ",", "and", "data", "is", "zero", "extended", "if", "REG", "is", "wider", "than", "MODE", ".", "If", "LE", "code", "is", "being", "generated", ",", "bswap", "loads", "are", "used", ".", "REG", "is", "the", "destination", "register", "to", "move", "the", "data", "into", ".", "MEM", "is", "the", "memory", "block", "being", "read", ".", "MODE", "is", "the", "mode", "of", "memory", "to", "use", "for", "the", "read", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "VideocoreAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "case", "MCK_ImmU5", ":", "case", "MCK_ImmS6", ":", "case", "MCK_ImmS16", ":", "if", "(", "AsmOp", "->", "isImm", "(", ")", ")", "return", "Match_ImmediateTooLarge", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "move_elim_pass", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "rl78" ]

[]

[ "<s>", "unsigned", "char", "M68kSubtarget", "::", "classifyExternalReference", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "nullptr", ")", ")", "return", "classifyLocalReference", "(", "nullptr", ")", ";", "if", "(", "isPositionIndependent", "(", ")", ")", "return", "M68kII", "::", "MO_GOTPCREL", ";", "return", "M68kII", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "external", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "M68k", "M68k", "M68kII::MO_GOTPCREL", "M68kII::MO_GOT" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "static", "unsigned", "getRegClass", "(", "bool", "IsVgpr", ",", "unsigned", "RegWidth", ")", "{", "if", "(", "IsVgpr", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown register width\"", ")", ";", "case", "1", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "}", "}", "switch", "(", "RegWidth", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown register width\"", ")", ";", "case", "1", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "SReg_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "SReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "SReg_512RegClassID", ";", "}", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AMDGPU", "\"Unknown register width\"", "1", "AMDGPU::VGPR_32RegClassID", "2", "AMDGPU::VReg_64RegClassID", "3", "AMDGPU::VReg_96RegClassID", "4", "AMDGPU::VReg_128RegClassID", "8", "AMDGPU::VReg_256RegClassID", "16", "AMDGPU::VReg_512RegClassID", "\"Unknown register width\"", "1", "AMDGPU::SGPR_32RegClassID", "2", "AMDGPU::SGPR_64RegClassID", "4", "AMDGPU::SReg_128RegClassID", "8", "AMDGPU::SReg_256RegClassID", "16", "AMDGPU::SReg_512RegClassID" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "initializeSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ")", "const", "{", "ARMFunctionInfo", "*", "AFI", "=", "Entry", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setIsSplitCSR", "(", "true", ")", ";", "}", "</s>" ]

[ "Perform", "necessary", "initialization", "to", "handle", "a", "subset", "of", "CSRs", "explicitly", "via", "copies", "." ]

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

[]

[ "<s>", "static", "void", "microblaze_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "arg_number", "++", ";", "switch", "(", "mode", ")", "{", "case", "E_VOIDmode", ":", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_BLKmode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "int_size_in_bytes", "(", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_SFmode", ":", "cum", "->", "arg_words", "++", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "1", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DFmode", ":", "cum", "->", "arg_words", "+=", "2", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "2", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "2", ";", "break", ";", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_TImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "++", ";", "break", ";", "}", "}", "</s>" ]

[ "Advance", "the", "argument", "to", "the", "next", "argument", "position", "." ]

[ "microblaze", "1", "1", "1", "1", "2", "1", "1", "2", "2", "2", "2", "1", "2", "1", "2", "1" ]

[]

[ "<s>", "const", "MCGSCANodeMap", "&", "getNodes", "(", ")", "const", "{", "return", "Nodes", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "void", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "case", "ISD", "::", "INLINEASM_BR", ":", "{", "if", "(", "tryInlineAsm", "(", "N", ")", ")", "return", ";", "break", ";", "}", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "ReplaceNode", "(", "N", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "CurDAG", "->", "getCopyToReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "SP", "::", "Y", ",", "TopPart", ",", "SDValue", "(", ")", ")", ".", "getValue", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "ISD::INLINEASM", "ISD::INLINEASM_BR", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::Y", "1", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETSTACKTOP", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "MEMBARRIER", ")", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER" ]

[]

[ "<s>", "Register", "X86TargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "assert", "(", "!", "isFuncletEHPersonality", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", ")", ")", ";", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::RDX", "X86::EDX" ]

[]

[ "<s>", "static", "section", "*", "riscv_elf_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "s", "=", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "if", "(", "riscv_size_ok_for_small_data_p", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ")", ")", "{", "if", "(", "startswith", "(", "s", "->", "named", ".", "name", ",", "\".rodata.cst\"", ")", ")", "{", "char", "*", "name", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "s", "->", "named", ".", "name", ")", "+", "2", ")", ";", "sprintf", "(", "name", ",", "\".s%s\"", ",", "s", "->", "named", ".", "name", "+", "1", ")", ";", "return", "get_section", "(", "name", ",", "s", "->", "named", ".", "common", ".", "flags", ",", "NULL", ")", ";", "}", "if", "(", "s", "==", "data_section", ")", "return", "sdata_section", ";", "}", "return", "s", ";", "}", "</s>" ]

[ "Return", "a", "section", "for", "X", ",", "handling", "small", "data", "." ]

[ "riscv", "\".rodata.cst\"", "2", "\".s%s\"", "1" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "BPF" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "LLT", "Ty", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Subtarget", "->", "requiresStrictAlign", "(", ")", ")", "return", "false", ";", "if", "(", "Fast", ")", "{", "*", "Fast", "=", "!", "Subtarget", "->", "isMisaligned128StoreSlow", "(", ")", "||", "Ty", ".", "getSizeInBytes", "(", ")", "!=", "16", "||", "Alignment", "<=", "2", "||", "Ty", "==", "LLT", "::", "vector", "(", "2", ",", "64", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "16", "2", "2", "64" ]

[]

[ "<s>", "static", "gimple", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "gimple", "stmt", ";", "for", "(", ";", ";", ")", "{", "enum", "tree_code", "code", ";", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "gimple_code", "(", "stmt", ")", "==", "GIMPLE_PHI", ")", "return", "stmt", ";", "if", "(", "!", "is_gimple_assign", "(", "stmt", ")", "||", "gimple_assign_lhs", "(", "stmt", ")", "!=", "lhs", ")", "return", "NULL", ";", "if", "(", "TREE_CODE", "(", "gimple_assign_rhs1", "(", "stmt", ")", ")", "!=", "SSA_NAME", ")", "return", "stmt", ";", "code", "=", "gimple_assign_rhs_code", "(", "stmt", ")", ";", "if", "(", "!", "CONVERT_EXPR_CODE_P", "(", "code", ")", "&&", "(", "(", "code", "!=", "PLUS_EXPR", "&&", "code", "!=", "POINTER_PLUS_EXPR", ")", "||", "TREE_CODE", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", "!=", "INTEGER_CST", "||", "!", "tree_fits_uhwi_p", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", ")", ")", "return", "stmt", ";", "lhs", "=", "gimple_assign_rhs1", "(", "stmt", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "enableAggressiveInterleaving", "(", "bool", "LoopHasReductions", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Do", "n't", "restrict", "interleaved", "unrolling", "to", "small", "loops", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "z8k_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "z8k_libcall_value", "(", "TYPE_MODE", "(", "valtype", ")", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "Two", "ways", "to", "return", "on", "the", "Z8k", ".", "in", "r2/rr2/rq2", "for", "HI", ",", "SI", ",", "DI", "stuff", "or", "r7/rr6/rq4", "stuff", "." ]

[ "z8k" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", ",", "llvm", "::", "MCInst", "&", ")", "const", "override", "{", "llvm_unreachable", "(", "\"Cannot relax instructions\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "\"Cannot relax instructions\"" ]

[]

[ "<s>", "void", "nvptx_record_needed_fndecl", "(", "tree", "decl", ")", "{", "if", "(", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "NULL_TREE", ")", "{", "tree", "*", "slot", "=", "needed_fndecls_htab", "->", "find_slot", "(", "decl", ",", "INSERT", ")", ";", "if", "(", "*", "slot", "==", "NULL", ")", "*", "slot", "=", "decl", ";", "}", "else", "nvptx_record_fndecl", "(", "decl", ")", ";", "}", "</s>" ]

[ "Record", "that", "we", "need", "to", "emit", "a", "ptx", "decl", "for", "DECL", ".", "Either", "do", "it", "now", ",", "or", "record", "it", "for", "later", "in", "case", "we", "have", "no", "argument", "information", "at", "this", "point", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "arm_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "(", "to", "==", "FRAME_POINTER_REGNUM", "&&", "from", "==", "ARG_POINTER_REGNUM", ")", "?", "false", ":", "(", "to", "==", "STACK_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "?", "false", ":", "(", "to", "==", "ARM_HARD_FRAME_POINTER_REGNUM", "&&", "TARGET_THUMB", ")", "?", "false", ":", "(", "to", "==", "THUMB_HARD_FRAME_POINTER_REGNUM", "&&", "TARGET_ARM", ")", "?", "false", ":", "true", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "Note", "that", "ARG_POINTER_REGNUM", "and", "HARD_FRAME_POINTER_REGNUM", "are", "in", "fact", "the", "same", "thing", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "FRAME_POINTER_REGNUM", "into", "HARD_FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "or", "ARG_POINTER_REGNUM", "." ]

[ "arm" ]

[]

[ "<s>", "static", "unsigned", "getIntrinsicID", "(", "const", "SDNode", "*", "N", ")", "{", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "Intrinsic", "::", "not_intrinsic", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IID", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "IID", "<", "Intrinsic", "::", "num_intrinsics", ")", "return", "IID", ";", "return", "Intrinsic", "::", "not_intrinsic", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "target", "intrinsic", "ID", "of", "a", "function", ",", "or", "0", "." ]

[ "ARM64", "Intrinsic::not_intrinsic", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::num_intrinsics", "Intrinsic::not_intrinsic" ]

[]

[ "<s>", "const", "LoongArchRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "int", "riscv_address_insns", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "might_split_p", ")", "{", "struct", "riscv_address_info", "addr", "=", "{", "}", ";", "int", "n", "=", "1", ";", "if", "(", "!", "riscv_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "{", "return", "3", ";", "}", "if", "(", "mode", "!=", "BLKmode", "&&", "might_split_p", ")", "n", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "addr", ".", "type", "==", "ADDRESS_LO_SUM", ")", "n", "+=", "riscv_symbol_insns", "(", "addr", ".", "symbol_type", ")", "-", "1", ";", "return", "n", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "or", "store", "a", "value", "of", "mode", "MODE", "at", "address", "X", ".", "Return", "0", "if", "X", "is", "n't", "valid", "for", "MODE", ".", "Assume", "that", "multiword", "moves", "may", "need", "to", "be", "split", "into", "word", "moves", "if", "MIGHT_SPLIT_P", ",", "otherwise", "assume", "that", "a", "single", "load", "or", "store", "is", "enough", "." ]

[ "riscv", "1", "3", "1", "1" ]

[]

[ "<s>", "void", "KudeyarFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "4", ",", "-", "4", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FP register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "4", "4", "\"Slot for FP register must be last in order to be found!\"" ]

[]

[ "<s>", "void", "insert", "(", "const", "GepNode", "*", "N", ")", "{", "Map", ".", "insert", "(", "std", "::", "make_pair", "(", "N", ",", "++", "LastNum", ")", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "TLCS900RegisterInfo", "::", "getPointerRegClass", "(", "unsigned", "Kind", ")", "const", "{", "return", "&", "TLCS900", "::", "GR16RegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "TLCS900", "TLCS900", "TLCS900::GR16RegClass" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_LOAD_STORE_OPT_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "M680x0AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "MCInstLowering", "=", "make_unique", "<", "M680x0MCInstLower", ">", "(", "MF", ",", "*", "this", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "M680x0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "allowTruncateForTailCall", "(", "Type", "*", "Ty1", ",", "Type", "*", "Ty2", ")", "const", "{", "if", "(", "!", "Ty1", "->", "isIntegerTy", "(", ")", "||", "!", "Ty2", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isTypeLegal", "(", "EVT", "::", "getEVT", "(", "Ty1", ")", ")", ")", "return", "false", ";", "assert", "(", "Ty1", "->", "getPrimitiveSizeInBits", "(", ")", "<=", "64", "&&", "\"i128 is probably not a noop\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "truncation", "from", "FromTy", "to", "ToTy", "is", "permitted", "when", "deciding", "whether", "a", "call", "is", "in", "tail", "position", "." ]

[ "ARM", "ARM", "64", "\"i128 is probably not a noop\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Expand Predicate Spill Code\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Expand Predicate Spill Code\"" ]

[]

[ "<s>", "static", "void", "mips_epilogue_set_cfa", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "mips_epilogue_emit_cfa_restores", "(", ")", ";", "if", "(", "reg", "!=", "mips_epilogue", ".", "cfa_reg", "||", "offset", "!=", "mips_epilogue", ".", "cfa_offset", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "mips_epilogue", ".", "cfa_reg", "=", "reg", ";", "mips_epilogue", ".", "cfa_offset", "=", "offset", ";", "}", "}", "</s>" ]

[ "Like", "mips_epilogue_emit_cfa_restores", ",", "but", "also", "record", "that", "the", "CFA", "is", "now", "at", "REG", "+", "OFFSET", "." ]

[ "mips", "1" ]

[]

[ "<s>", "bool", "arm_validize_comparison", "(", "rtx", "*", "comparison", ",", "rtx", "*", "op1", ",", "rtx", "*", "op2", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "comparison", ")", ";", "int", "code_int", ";", "machine_mode", "mode", "=", "(", "GET_MODE", "(", "*", "op1", ")", "==", "VOIDmode", ")", "?", "GET_MODE", "(", "*", "op2", ")", ":", "GET_MODE", "(", "*", "op1", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "*", "op1", ")", "!=", "VOIDmode", "||", "GET_MODE", "(", "*", "op2", ")", "!=", "VOIDmode", ")", ";", "if", "(", "code", "==", "UNEQ", "||", "code", "==", "LTGT", ")", "return", "false", ";", "code_int", "=", "(", "int", ")", "code", ";", "arm_canonicalize_comparison", "(", "&", "code_int", ",", "op1", ",", "op2", ",", "0", ")", ";", "PUT_CODE", "(", "*", "comparison", ",", "(", "enum", "rtx_code", ")", "code_int", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "if", "(", "!", "arm_add_operand", "(", "*", "op1", ",", "mode", ")", ")", "*", "op1", "=", "force_reg", "(", "mode", ",", "*", "op1", ")", ";", "if", "(", "!", "arm_add_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "return", "true", ";", "case", "E_DImode", ":", "return", "true", ";", "case", "E_HFmode", ":", "if", "(", "!", "TARGET_VFP_FP16INST", ")", "break", ";", "mode", "=", "SFmode", ";", "*", "op1", "=", "convert_to_mode", "(", "mode", ",", "*", "op1", ",", "1", ")", ";", "*", "op2", "=", "convert_to_mode", "(", "mode", ",", "*", "op2", ",", "1", ")", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "if", "(", "!", "vfp_compare_operand", "(", "*", "op1", ",", "mode", ")", ")", "*", "op1", "=", "force_reg", "(", "mode", ",", "*", "op1", ")", ";", "if", "(", "!", "vfp_compare_operand", "(", "*", "op2", ",", "mode", ")", ")", "*", "op2", "=", "force_reg", "(", "mode", ",", "*", "op2", ")", ";", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "valid", "comparison", "operation", "and", "makes", "the", "operands", "in", "a", "form", "that", "is", "valid", "." ]

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

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "Is64Bit", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR32", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR32", ")", "{", "++", "I", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"TLS Dynamic Call Fixup:\\n \"", "<<", "*", "MI", ";", ")", ";", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "unsigned", "Opc1", ",", "Opc2", ";", "SmallVector", "<", "unsigned", ",", "4", ">", "OrigRegs", ";", "OrigRegs", ".", "push_back", "(", "OutReg", ")", ";", "OrigRegs", ".", "push_back", "(", "InReg", ")", ";", "OrigRegs", ".", "push_back", "(", "GPR3", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode inconsistency error\"", ")", ";", "case", "PPC", "::", "ADDItlsgdLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsgdLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL32", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR32", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL32", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR32", ";", "break", ";", "}", "MachineInstr", "*", "Addi", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc1", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "Addi", "->", "addOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "First", "=", "I", ";", "--", "First", ";", "MachineInstr", "*", "Call", "=", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc2", ")", ",", "GPR3", ")", ".", "addReg", "(", "GPR3", ")", ")", ";", "Call", "->", "addOperand", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "MachineBasicBlock", "::", "iterator", "Last", "=", "I", ";", "--", "Last", ";", "++", "I", ";", "MI", "->", "removeFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "&", "MBB", ",", "First", ",", "Last", ",", "OrigRegs", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsldLADDR32", "\"TLS Dynamic Call Fixup:\\n \"", "0", "1", "PPC::X3", "PPC::R3", "4", "\"Opcode inconsistency error\"", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsgdL", "PPC::GETtlsADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsldL", "PPC::GETtlsldADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsgdL32", "PPC::GETtlsADDR32", "PPC::ADDItlsldLADDR32", "PPC::ADDItlsldL32", "PPC::GETtlsldADDR32", "2", "3" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "i", ",", "ArgInfos", ",", "OrigArgIndices", ")", ";", "++", "i", ";", "}", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "MIRBuilder", ",", "ArgInfos", ",", "OrigArgIndices", ",", "[", "&", "]", "(", "ISD", "::", "ArgFlagsTy", "flags", ",", "EVT", "vt", ",", "EVT", "argvt", ",", "bool", "used", ",", "unsigned", "origIdx", ",", "unsigned", "partOffs", ")", "{", "Ins", ".", "emplace_back", "(", "flags", ",", "vt", ",", "argvt", ",", "used", ",", "origIdx", ",", "partOffs", ")", ";", "}", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ")", ";", "IncomingValueHandler", "Handler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "Mips", "Mips", "Mips", "Mips", "8", "8", "0", "ISD::InputArg", "8", "ISD::ArgFlagsTy", "16", "Mips" ]

[]

[ "<s>", "void", "rs6000_split_logical", "(", "rtx", "operands", "[", "3", "]", ",", "enum", "rtx_code", "code", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "machine_mode", "sub_mode", ";", "rtx", "op0", ",", "op1", ",", "op2", ";", "int", "sub_size", ",", "regno0", ",", "regno1", ",", "nregs", ",", "i", ";", "if", "(", "mode", "==", "DImode", "&&", "!", "TARGET_POWERPC64", ")", "{", "rs6000_split_logical_di", "(", "operands", ",", "code", ",", "complement_final_p", ",", "complement_op1_p", ",", "complement_op2_p", ")", ";", "return", ";", "}", "op0", "=", "operands", "[", "0", "]", ";", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "(", "code", "==", "NOT", ")", "?", "NULL_RTX", ":", "operands", "[", "2", "]", ";", "sub_mode", "=", "(", "TARGET_POWERPC64", ")", "?", "DImode", ":", "SImode", ";", "sub_size", "=", "GET_MODE_SIZE", "(", "sub_mode", ")", ";", "regno0", "=", "REGNO", "(", "op0", ")", ";", "regno1", "=", "REGNO", "(", "op1", ")", ";", "gcc_assert", "(", "reload_completed", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "regno0", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "regno1", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", ")", ";", "nregs", "=", "rs6000_hard_regno_nregs", "[", "(", "int", ")", "mode", "]", "[", "regno0", "]", ";", "gcc_assert", "(", "nregs", ">", "1", ")", ";", "if", "(", "op2", "&&", "REG_P", "(", "op2", ")", ")", "gcc_assert", "(", "IN_RANGE", "(", "REGNO", "(", "op2", ")", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "++", ")", "{", "int", "offset", "=", "i", "*", "sub_size", ";", "rtx", "sub_op0", "=", "simplify_subreg", "(", "sub_mode", ",", "op0", ",", "mode", ",", "offset", ")", ";", "rtx", "sub_op1", "=", "simplify_subreg", "(", "sub_mode", ",", "op1", ",", "mode", ",", "offset", ")", ";", "rtx", "sub_op2", "=", "(", "(", "code", "==", "NOT", ")", "?", "NULL_RTX", ":", "simplify_subreg", "(", "sub_mode", ",", "op2", ",", "mode", ",", "offset", ")", ")", ";", "rs6000_split_logical_inner", "(", "sub_op0", ",", "sub_op1", ",", "sub_op2", ",", "code", ",", "sub_mode", ",", "complement_final_p", ",", "complement_op1_p", ",", "complement_op2_p", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Split", "the", "insns", "that", "make", "up", "boolean", "operations", "operating", "on", "multiple", "GPR", "registers", ".", "The", "boolean", "MD", "patterns", "ensure", "that", "the", "inputs", "either", "are", "exactly", "the", "same", "as", "the", "output", "registers", ",", "or", "there", "is", "no", "overlap", ".", "OPERANDS", "is", "an", "array", "containing", "the", "destination", "and", "two", "input", "operands", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_secondary_reload_trace", "(", "int", "line", ",", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "set", ",", "clobber", ";", "gcc_assert", "(", "reg", "!=", "NULL_RTX", "&&", "mem", "!=", "NULL_RTX", "&&", "scratch", "!=", "NULL_RTX", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_secondary_reload_inner:%d, type = %s\\n\"", ",", "line", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "if", "(", "store_p", ")", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "else", "set", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ";", "debug_rtx", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "</s>" ]

[ "Better", "tracing", "for", "rs6000_secondary_reload_inner", "." ]

[ "powerpcspe", "\"rs6000_secondary_reload_inner:%d, type = %s\\n\"", "\"store\"", "\"load\"", "2" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Compress Jump Tables\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Compress Jump Tables\"" ]

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "HasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF", "WebAssembly::isArgument" ]

[]

[ "<s>", "const", "CallLowering", "*", "RISCVSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "bool", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "ArrayRef", "<", "SMRange", ">", "(", ")", ")", "{", "return", "Parser", ".", "Warning", "(", "L", ",", "Msg", ",", "Ranges", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "return", "NumElts", ";", "if", "(", "Size", "==", "64", ")", "return", "2", "*", "NumElts", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "return", "(", "VT", ".", "getVectorNumElements", "(", ")", "+", "1", ")", "/", "2", ";", "}", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "AMDGPU", "SI", "AMDGPU", "32", "64", "2", "16", "1", "2" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "PrintImmValue", "=", "[", "&", "]", "(", "const", "MCExpr", "*", "Val", ",", "const", "char", "*", "VName", ")", "{", "if", "(", "Val", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Constant", ")", "{", "if", "(", "auto", "Imm", "=", "cast", "<", "MCConstantExpr", ">", "(", "Val", ")", "->", "getValue", "(", ")", ")", "OS", "<<", "VName", "<<", "Imm", ";", "}", "else", "if", "(", "Val", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "{", "if", "(", "auto", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Val", ")", ")", "{", "const", "MCSymbol", "&", "Sym", "=", "SRE", "->", "getSymbol", "(", ")", ";", "if", "(", "const", "char", "*", "SymNameStr", "=", "Sym", ".", "getName", "(", ")", ".", "data", "(", ")", ")", "OS", "<<", "VName", "<<", "SymNameStr", ";", "}", "}", "}", ";", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"Reg:\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Reg", ".", "RegNo", ")", ";", "break", ";", "case", "DXRegister", ":", "OS", "<<", "\"DXReg\"", ";", "break", ";", "case", "Immediate", ":", "PrintImmValue", "(", "Imm", ".", "Val", ",", "\"Imm:\"", ")", ";", "break", ";", "case", "Prefix", ":", "OS", "<<", "\"Prefix:\"", "<<", "Pref", ".", "Prefixes", ";", "break", ";", "case", "Memory", ":", "OS", "<<", "\"Memory: ModeSize=\"", "<<", "Mem", ".", "ModeSize", ";", "if", "(", "Mem", ".", "Size", ")", "OS", "<<", "\",Size=\"", "<<", "Mem", ".", "Size", ";", "if", "(", "Mem", ".", "BaseReg", ")", "OS", "<<", "\",BaseReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "BaseReg", ")", ";", "if", "(", "Mem", ".", "IndexReg", ")", "OS", "<<", "\",IndexReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "IndexReg", ")", ";", "if", "(", "Mem", ".", "Scale", ")", "OS", "<<", "\",Scale=\"", "<<", "Mem", ".", "Scale", ";", "if", "(", "Mem", ".", "Disp", ")", "PrintImmValue", "(", "Mem", ".", "Disp", ",", "\",Disp=\"", ")", ";", "if", "(", "Mem", ".", "SegReg", ")", "OS", "<<", "\",SegReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "SegReg", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "X86", "\"Reg:\"", "X86", "\"DXReg\"", "\"Imm:\"", "\"Prefix:\"", "\"Memory: ModeSize=\"", "\",Size=\"", "\",BaseReg=\"", "X86", "\",IndexReg=\"", "X86", "\",Scale=\"", "\",Disp=\"", "\",SegReg=\"", "X86" ]

[]

[ "<s>", "unsigned", "P2MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"--- creating fixup for jump operand\\n\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "P2", "::", "fixup_P2_PC20", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "P2", "P2", "\"getJumpTargetOpValue expects only expressions\"", "\"--- creating fixup for jump operand\\n\"", "0", "P2::fixup_P2_PC20", "0" ]

[]

[ "<s>", "void", "TOYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== custom Opcode \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"Selecting: \"", "\"\\n\"", "\"== custom Opcode \"", "\"\\n\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "RISCV" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "AArch64PassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "return", "getStandardCSEConfigForOpt", "(", "TM", "->", "getOptLevel", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]

[ "AArch64", "AArch64" ]

[]