Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"TMS320C64X Instruction Selection\"", ";", "}", "</s>" ]

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

[ "TMS320C64X", "\"TMS320C64X Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "hwloop_pattern_reg", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "reg", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "!=", "CODE_FOR_loop_end", ")", "return", "NULL_RTX", ";", "reg", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NULL_RTX", ";", "return", "reg", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "This", "function", "examines", "INSN", ";", "if", "it", "is", "a", "doloop_end", "pattern", "we", "recognize", ",", "return", "the", "reg", "rtx", "for", "the", "loop", "counter", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getMatchingSuperRegClass", "(", "const", "TargetRegisterClass", "*", "A", ",", "const", "TargetRegisterClass", "*", "B", ",", "unsigned", "SubIdx", ")", "const", "{", "switch", "(", "SubIdx", ")", "{", "default", ":", "return", "0", ";", "case", "1", ":", "case", "2", ":", "case", "3", ":", "case", "4", ":", "if", "(", "A", "->", "getSize", "(", ")", "==", "8", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "SPR_8RegClass", ")", "return", "&", "ARM", "::", "DPR_8RegClass", ";", "assert", "(", "B", "==", "&", "ARM", "::", "SPRRegClass", "&&", "\"Expecting SPR register class!\"", ")", ";", "if", "(", "A", "==", "&", "ARM", "::", "DPR_8RegClass", ")", "return", "A", ";", "return", "&", "ARM", "::", "DPR_VFP2RegClass", ";", "}", "assert", "(", "A", "->", "getSize", "(", ")", "==", "16", "&&", "\"Expecting a Q register class!\"", ")", ";", "if", "(", "B", "==", "&", "ARM", "::", "SPR_8RegClass", ")", "return", "&", "ARM", "::", "QPR_8RegClass", ";", "return", "&", "ARM", "::", "QPR_VFP2RegClass", ";", "case", "5", ":", "case", "6", ":", "if", "(", "B", "==", "&", "ARM", "::", "DPR_VFP2RegClass", ")", "return", "&", "ARM", "::", "QPR_VFP2RegClass", ";", "if", "(", "B", "==", "&", "ARM", "::", "DPR_8RegClass", ")", "return", "&", "ARM", "::", "QPR_8RegClass", ";", "return", "A", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "getMatchingSuperRegClass", "-", "Return", "a", "subclass", "of", "the", "specified", "register", "class", "A", "so", "that", "each", "register", "in", "it", "has", "a", "sub-register", "of", "the", "specified", "sub-register", "index", "which", "is", "in", "the", "specified", "register", "class", "B", "." ]

[ "ARM", "ARM", "0", "1", "2", "3", "4", "8", "ARM::SPR_8RegClass", "ARM::DPR_8RegClass", "ARM::SPRRegClass", "\"Expecting SPR register class!\"", "ARM::DPR_8RegClass", "ARM::DPR_VFP2RegClass", "16", "\"Expecting a Q register class!\"", "ARM::SPR_8RegClass", "ARM::QPR_8RegClass", "ARM::QPR_VFP2RegClass", "5", "6", "ARM::DPR_VFP2RegClass", "ARM::QPR_VFP2RegClass", "ARM::DPR_8RegClass", "ARM::QPR_8RegClass", "0" ]

[]

[ "<s>", "static", "inline", "SlotWithTag", "getEmptyKey", "(", ")", "{", "return", "{", "-", "2", ",", "-", "2", ";", "}", "</s>" ]

[ "Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "." ]

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

[]

[ "<s>", "rtx", "rs6000_longcall_ref", "(", "rtx", "call_ref", ")", "{", "const", "char", "*", "call_name", ";", "tree", "node", ";", "if", "(", "GET_CODE", "(", "call_ref", ")", "!=", "SYMBOL_REF", ")", "return", "call_ref", ";", "call_name", "=", "XSTR", "(", "call_ref", ",", "0", ")", ";", "if", "(", "*", "call_name", "==", "'.'", ")", "{", "while", "(", "*", "call_name", "==", "'.'", ")", "call_name", "++", ";", "node", "=", "get_identifier", "(", "call_name", ")", ";", "call_ref", "=", "gen_rtx_SYMBOL_REF", "(", "VOIDmode", ",", "IDENTIFIER_POINTER", "(", "node", ")", ")", ";", "}", "return", "force_reg", "(", "Pmode", ",", "call_ref", ")", ";", "}", "</s>" ]

[ "Return", "a", "reference", "suitable", "for", "calling", "a", "function", "with", "the", "longcall", "attribute", "." ]

[ "powerpcspe", "0" ]

[]

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

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

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

[]

[ "<s>", "TargetPassConfig", "*", "NyuziTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "NyuziPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Nyuzi", "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "static", "bool", "aarch64_decl_is_long_call_p", "(", "const_tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "DECL", "should", "be", "treated", "as", "long-calls", "(", "ie", "called", "via", "a", "register", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ARMRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "DestReg", ",", "int", "Val", ",", "unsigned", "Pred", ",", "unsigned", "PredReg", ",", "const", "TargetInstrInfo", "*", "TII", ",", "bool", "isThumb", ",", "DebugLoc", "dl", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "Int32Ty", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "if", "(", "isThumb", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "tLDRcp", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "ARM", "::", "LDRcp", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "4", "ARM::tLDRcp", "ARM::LDRcp", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "ix86_test_loading_full_dump", "(", ")", "{", "rtl_dump_test", "t", "(", "SELFTEST_LOCATION", ",", "locate_file", "(", "\"x86_64/times-two.rtl\"", ")", ")", ";", "ASSERT_STREQ", "(", "\"times_two\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "cfun", "->", "decl", ")", ")", ")", ";", "rtx_insn", "*", "insn_1", "=", "get_insn_by_uid", "(", "1", ")", ";", "ASSERT_EQ", "(", "NOTE", ",", "GET_CODE", "(", "insn_1", ")", ")", ";", "rtx_insn", "*", "insn_7", "=", "get_insn_by_uid", "(", "7", ")", ";", "ASSERT_EQ", "(", "INSN", ",", "GET_CODE", "(", "insn_7", ")", ")", ";", "ASSERT_EQ", "(", "PARALLEL", ",", "GET_CODE", "(", "PATTERN", "(", "insn_7", ")", ")", ")", ";", "rtx_insn", "*", "insn_15", "=", "get_insn_by_uid", "(", "15", ")", ";", "ASSERT_EQ", "(", "INSN", ",", "GET_CODE", "(", "insn_15", ")", ")", ";", "ASSERT_EQ", "(", "USE", ",", "GET_CODE", "(", "PATTERN", "(", "insn_15", ")", ")", ")", ";", "ASSERT_EQ", "(", "REG", ",", "GET_CODE", "(", "crtl", "->", "return_rtx", ")", ")", ";", "ASSERT_EQ", "(", "0", ",", "REGNO", "(", "crtl", "->", "return_rtx", ")", ")", ";", "ASSERT_EQ", "(", "SImode", ",", "GET_MODE", "(", "crtl", "->", "return_rtx", ")", ")", ";", "}", "</s>" ]

[ "Verify", "that", "the", "RTL", "loader", "copes", "a", "dump", "from", "print_rtx_function", ".", "This", "test", "is", "target-specific", "since", "the", "dump", "contains", "target-specific", "hard", "reg", "names", "." ]

[ "i386", "\"x86_64/times-two.rtl\"", "\"times_two\"", "1", "7", "15", "0" ]

[]

[ "<s>", "static", "rtx", "single_set_pattern", "(", "rtx", "pattern", ")", "{", "rtx", "set", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "COND_EXEC", ")", "pattern", "=", "COND_EXEC_CODE", "(", "pattern", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", "return", "pattern", ";", "else", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ",", "set", "=", "0", ";", "i", "<", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "sub", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "switch", "(", "GET_CODE", "(", "sub", ")", ")", "{", "case", "USE", ":", "case", "CLOBBER", ":", "break", ";", "case", "SET", ":", "if", "(", "set", ")", "return", "0", ";", "else", "set", "=", "sub", ";", "break", ";", "default", ":", "return", "0", ";", "}", "}", "return", "set", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Given", "a", "PATTERN", ",", "return", "a", "SET", "expression", "if", "this", "PATTERN", "has", "only", "a", "single", "SET", ",", "possibly", "conditionally", "executed", ".", "It", "may", "also", "have", "CLOBBERs", ",", "USEs", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "ptr_mode", ",", "PROBE_STACK_FIRST_REG", ")", ";", "gcc_assert", "(", "(", "first", "%", "ARITH_FACTOR", ")", "==", "0", ")", ";", "if", "(", "size", "<=", "PROBE_INTERVAL", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "size", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "ptr_mode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "base", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "ptr_mode", ",", "reg1", ",", "base", "-", "size", ")", ")", ";", "}", "else", "if", "(", "size", "<=", "4", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ",", "rem", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "ptr_mode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "PROBE_INTERVAL", ")", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "for", "(", "i", "=", "2", "*", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "{", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "ptr_mode", ",", "reg1", ",", "-", "PROBE_INTERVAL", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "}", "rem", "=", "size", "-", "(", "i", "-", "PROBE_INTERVAL", ")", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "ptr_mode", ",", "reg1", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "ptr_mode", ",", "reg1", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "ptr_mode", ",", "reg1", ",", "-", "rem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "ptr_mode", ",", "PROBE_STACK_SECOND_REG", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "size", "&", "-", "PROBE_INTERVAL", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "ptr_mode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ";", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "ptr_mode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "rounded_size", ")", ")", ")", ";", "if", "(", "ptr_mode", "==", "DImode", ")", "emit_insn", "(", "gen_probe_stack_range_di", "(", "reg1", ",", "reg1", ",", "reg2", ")", ")", ";", "else", "emit_insn", "(", "gen_probe_stack_range_si", "(", "reg1", ",", "reg1", ",", "reg2", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "{", "HOST_WIDE_INT", "rem", "=", "size", "-", "rounded_size", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "ptr_mode", ",", "reg2", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "ptr_mode", ",", "reg2", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "ptr_mode", ",", "reg2", ",", "-", "rem", ")", ")", ";", "}", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "aarch64", "0", "4", "2", "256", "256" ]

[]

[ "<s>", "static", "rtx", "s390_execute_target", "(", "rtx", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "s390_execute_label", "(", "insn", ")", ")", ";", "if", "(", "XVECLEN", "(", "pattern", ",", "0", ")", "==", "2", ")", "{", "pattern", "=", "copy_rtx", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", ")", ";", "}", "else", "{", "rtvec", "vec", "=", "rtvec_alloc", "(", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ";", "i", "++", ")", "RTVEC_ELT", "(", "vec", ",", "i", ")", "=", "copy_rtx", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", "+", "1", ")", ")", ";", "pattern", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "}", "return", "pattern", ";", "}", "</s>" ]

[ "For", "an", "execute", "INSN", ",", "extract", "the", "execute", "target", "template", "." ]

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

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "CSKY" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedLoadStores", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "VecTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "DataTy", ")", ")", "{", "if", "(", "VecTy", "->", "getNumElements", "(", ")", "==", "2", ")", "return", "false", ";", "unsigned", "VecWidth", "=", "DataTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "VecWidth", "!=", "128", "&&", "VecTy", "->", "getElementType", "(", ")", "->", "isFloatingPointTy", "(", ")", ")", "return", "false", ";", "}", "unsigned", "EltWidth", "=", "DataTy", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "EltWidth", "==", "32", "&&", "(", "!", "Alignment", "||", "Alignment", ">=", "4", ")", ")", "||", "(", "EltWidth", "==", "16", "&&", "(", "!", "Alignment", "||", "Alignment", ">=", "2", ")", ")", "||", "(", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

[ "ARM", "ARM", "2", "128", "32", "4", "16", "2", "8" ]

[]

[ "<s>", "int", "ix86_expand_strlen", "(", "rtx", "out", ",", "rtx", "src", ",", "rtx", "eoschar", ",", "rtx", "align", ")", "{", "rtx", "addr", ",", "scratch1", ",", "scratch2", ",", "scratch3", ",", "scratch4", ";", "if", "(", "TARGET_UNROLL_STRLEN", "&&", "eoschar", "==", "const0_rtx", "&&", "optimize", ">", "1", "&&", "!", "TARGET_INLINE_ALL_STRINGOPS", "&&", "!", "optimize_size", "&&", "(", "GET_CODE", "(", "align", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "align", ")", "<", "4", ")", ")", "return", "0", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "scratch1", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_UNROLL_STRLEN", "&&", "eoschar", "==", "const0_rtx", "&&", "optimize", ">", "1", "&&", "!", "optimize_size", ")", "{", "emit_move_insn", "(", "out", ",", "addr", ")", ";", "ix86_expand_strlensi_unroll_1", "(", "out", ",", "src", ",", "align", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_subdi3", "(", "out", ",", "out", ",", "addr", ")", ")", ";", "else", "emit_insn", "(", "gen_subsi3", "(", "out", ",", "out", ",", "addr", ")", ")", ";", "}", "else", "{", "rtx", "unspec", ";", "scratch2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "scratch3", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "scratch4", "=", "force_reg", "(", "Pmode", ",", "constm1_rtx", ")", ";", "emit_move_insn", "(", "scratch3", ",", "addr", ")", ";", "eoschar", "=", "force_reg", "(", "QImode", ",", "eoschar", ")", ";", "emit_insn", "(", "gen_cld", "(", ")", ")", ";", "src", "=", "replace_equiv_address_nv", "(", "src", ",", "scratch3", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "4", ",", "src", ",", "eoschar", ",", "align", ",", "scratch4", ")", ",", "UNSPEC_SCAS", ")", ";", "emit_insn", "(", "gen_strlenqi_1", "(", "scratch1", ",", "scratch3", ",", "unspec", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "emit_insn", "(", "gen_one_cmpldi2", "(", "scratch2", ",", "scratch1", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "out", ",", "scratch2", ",", "constm1_rtx", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_one_cmplsi2", "(", "scratch2", ",", "scratch1", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "out", ",", "scratch2", ",", "constm1_rtx", ")", ")", ";", "}", "}", "return", "1", ";", "}", "</s>" ]

[ "Expand", "strlen", "." ]

[ "i386", "1", "4", "0", "0", "1", "4", "1" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreRegBankSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createMipsPostLegalizeCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "DL", "=", "CLI", ".", "DL", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "if", "(", "CallConv", "!=", "CallingConv", "::", "C", "&&", "CallConv", "!=", "CallingConv", "::", "Fast", "&&", "CallConv", "!=", "CallingConv", "::", "Cold", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support language-specific or target-specific \"", "\"calling conventions yet\"", ")", ";", "if", "(", "CLI", ".", "IsPatchPoint", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support patch point yet\"", ")", ";", "if", "(", "(", "CallConv", "==", "CallingConv", "::", "Fast", "&&", "CLI", ".", "IsTailCall", "&&", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "||", "(", "CLI", ".", "CS", "&&", "CLI", ".", "CS", "->", "isMustTailCall", "(", ")", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support tail call yet\"", ")", ";", "CLI", ".", "IsTailCall", "=", "false", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "if", "(", "Ins", ".", "size", "(", ")", ">", "1", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support more than 1 returned value yet\"", ")", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "IsVarArg", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support varargs yet\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "auto", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "PtrVT", ",", "true", ")", ";", "auto", "NB", "=", "DAG", ".", "getConstant", "(", "NumBytes", ",", "DL", ",", "PtrVT", ",", "true", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "NB", ",", "DL", ")", ";", "SmallVector", "<", "SDValue", ",", "16", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "Ops", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "SmallVector", "<", "EVT", ",", "8", ">", "Tys", ";", "for", "(", "const", "auto", "&", "In", ":", "Ins", ")", "Tys", ".", "push_back", "(", "In", ".", "VT", ")", ";", "Tys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "SDVTList", "TyList", "=", "DAG", ".", "getVTList", "(", "Tys", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "Ins", ".", "empty", "(", ")", "?", "WebAssemblyISD", "::", "CALL0", ":", "WebAssemblyISD", "::", "CALL1", ",", "DL", ",", "TyList", ",", "Ops", ")", ";", "if", "(", "Ins", ".", "empty", "(", ")", ")", "{", "Chain", "=", "Res", ";", "}", "else", "{", "InVals", ".", "push_back", "(", "Res", ")", ";", "Chain", "=", "Res", ".", "getValue", "(", "1", ")", ";", "}", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "NB", ",", "Zero", ",", "SDValue", "(", ")", ",", "DL", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "WebAssembly", "WebAssembly", "\"WebAssembly doesn't support language-specific or target-specific \"", "\"calling conventions yet\"", "\"WebAssembly doesn't support patch point yet\"", "\"WebAssembly doesn't support tail call yet\"", "ISD::InputArg", "1", "\"WebAssembly doesn't support more than 1 returned value yet\"", "\"WebAssembly doesn't support varargs yet\"", "16", "0", "16", "8", "MVT::Other", "WebAssemblyISD::CALL0", "WebAssemblyISD::CALL1", "1" ]

[]

[ "<s>", "static", "bool", "tilegx_emit_setcc_internal", "(", "rtx", "res", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "tmp", ";", "bool", "swap", "=", "false", ";", "if", "(", "cmp_mode", "==", "SFmode", "||", "cmp_mode", "==", "DFmode", ")", "return", "tilegx_emit_fp_setcc", "(", "res", ",", "code", ",", "cmp_mode", ",", "op0", ",", "op1", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "swap", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "swap", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "}", "if", "(", "!", "reg_or_0_operand", "(", "op0", ",", "cmp_mode", ")", ")", "op0", "=", "force_reg", "(", "cmp_mode", ",", "op0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", "&&", "!", "register_operand", "(", "op1", ",", "cmp_mode", ")", ")", "op1", "=", "force_reg", "(", "cmp_mode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "res", ",", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "int", "get_epiphany_condition_code", "(", "rtx", "comparison", ")", "{", "switch", "(", "GET_MODE", "(", "XEXP", "(", "comparison", ",", "0", ")", ")", ")", "{", "case", "CCmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "case", "LTU", ":", "return", "2", ";", "case", "GEU", ":", "return", "3", ";", "case", "GT", ":", "return", "4", ";", "case", "LE", ":", "return", "5", ";", "case", "GE", ":", "return", "6", ";", "case", "LT", ":", "return", "7", ";", "case", "GTU", ":", "return", "8", ";", "case", "LEU", ":", "return", "9", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_N_NEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "6", ";", "case", "NE", ":", "return", "7", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_C_LTUmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GEU", ":", "return", "2", ";", "case", "LTU", ":", "return", "3", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_C_GTUmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "LEU", ":", "return", "3", ";", "case", "GTU", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FPmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "10", ";", "case", "NE", ":", "return", "11", ";", "case", "LT", ":", "return", "12", ";", "case", "LE", ":", "return", "13", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_EQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_GTEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "0", ";", "case", "NE", ":", "return", "1", ";", "case", "GT", ":", "return", "4", ";", "case", "GE", ":", "return", "6", ";", "case", "UNLE", ":", "return", "5", ";", "case", "UNLT", ":", "return", "7", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_ORDmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "ORDERED", ":", "return", "9", ";", "case", "UNORDERED", ":", "return", "8", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_UNEQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNEQ", ":", "return", "9", ";", "case", "LTGT", ":", "return", "8", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "42", ")", ";", "}", "</s>" ]

[ "Returns", "the", "index", "of", "the", "EPIPHANY", "condition", "code", "string", "in", "`", "epiphany_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "." ]

[ "epiphany", "0", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "6", "7", "2", "3", "3", "2", "10", "11", "12", "13", "0", "1", "0", "1", "4", "6", "5", "7", "9", "8", "9", "8", "42" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "Hexagon", "::", "R31", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R31" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_DWARF_CFA", ":", "return", "lowerEH_DWARF_CFA", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "lowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART", "ISD::VAARG", "ISD::FCOPYSIGN", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::EH_DWARF_CFA", "ISD::FP_TO_SINT" ]

[]

[ "<s>", "unsigned", "AMDGPUTargetMachine", "::", "getAddressSpaceForPseudoSourceKind", "(", "unsigned", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "PseudoSourceValue", "::", "Stack", ":", "case", "PseudoSourceValue", "::", "FixedStack", ":", "return", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "case", "PseudoSourceValue", "::", "ConstantPool", ":", "case", "PseudoSourceValue", "::", "GOT", ":", "case", "PseudoSourceValue", "::", "JumpTable", ":", "case", "PseudoSourceValue", "::", "GlobalValueCallEntry", ":", "case", "PseudoSourceValue", "::", "ExternalSymbolCallEntry", ":", "case", "PseudoSourceValue", "::", "TargetCustom", ":", "return", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ";", "}", "return", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "}", "</s>" ]

[ "getAddressSpaceForPseudoSourceKind", "-", "Given", "the", "kind", "of", "memory", "(", "e.g", "." ]

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

[]

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

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

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

[]

[ "<s>", "void", "OR1KDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "SDLoc", "dl", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "OR1K", "::", "ADDI", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "else", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "VT", ",", "TFI", ",", "imm", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::FrameIndex", "0", "MVT::i32", "0", "OR1K::ADDI" ]

[]

[ "<s>", "static", "bool", "use_skip_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "jump_insn", "=", "next_active_insn", "(", "JUMP_LABEL_AS_INSN", "(", "insn", ")", ")", ";", "while", "(", "insn", ")", "{", "insn", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", "break", ";", "if", "(", "get_attr_length", "(", "insn", ")", "==", "4", "&&", "jump_insn", "==", "next_active_insn", "(", "insn", ")", ")", "return", "TRUE", ";", "if", "(", "get_attr_length", "(", "insn", ")", ">", "0", ")", "break", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", ",", "a", "forward", "jump", "insn", ",", "can", "use", "nullification", "to", "skip", "the", "following", "instruction", ".", "This", "avoids", "an", "extra", "cycle", "due", "to", "a", "mis-predicted", "branch", "when", "we", "fall", "through", "." ]

[ "pa", "0", "4", "0" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "Optional", "<", "Hexagon", "::", "ArchEnum", ">", "ArchVer", "=", "Hexagon", "::", "GetCpu", "(", "Hexagon", "::", "CpuTable", ",", "CPUString", ")", ";", "if", "(", "ArchVer", ")", "HexagonArchVersion", "=", "*", "ArchVer", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseAudioOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "SubtargetFeatures", "Features", "(", "FS", ")", ";", "auto", "IsQFloatFS", "=", "[", "]", "(", "StringRef", "F", ")", "{", "return", "F", "==", "\"+hvx-qfloat\"", "||", "F", "==", "\"-hvx-qfloat\"", ";", "}", ";", "if", "(", "!", "llvm", "::", "count_if", "(", "Features", ".", "getFeatures", "(", ")", ",", "IsQFloatFS", ")", ")", "{", "auto", "getHvxVersion", "=", "[", "&", "Features", "]", "(", "StringRef", "FS", ")", "->", "StringRef", "{", "for", "(", "StringRef", "F", ":", "llvm", "::", "reverse", "(", "Features", ".", "getFeatures", "(", ")", ")", ")", "{", "if", "(", "F", ".", "startswith", "(", "\"+hvxv\"", ")", ")", "return", "F", ";", "}", "for", "(", "StringRef", "F", ":", "llvm", "::", "reverse", "(", "Features", ".", "getFeatures", "(", ")", ")", ")", "{", "if", "(", "F", "==", "\"-hvx\"", ")", "return", "StringRef", "(", ")", ";", "if", "(", "F", ".", "startswith", "(", "\"+hvx\"", ")", "||", "F", "==", "\"-hvx\"", ")", "return", "F", ".", "take_front", "(", "4", ")", ";", "}", "return", "StringRef", "(", ")", ";", "}", ";", "bool", "AddQFloat", "=", "false", ";", "StringRef", "HvxVer", "=", "getHvxVersion", "(", "FS", ")", ";", "if", "(", "HvxVer", ".", "startswith", "(", "\"+hvxv\"", ")", ")", "{", "int", "Ver", "=", "0", ";", "if", "(", "!", "HvxVer", ".", "drop_front", "(", "5", ")", ".", "consumeInteger", "(", "10", ",", "Ver", ")", "&&", "Ver", ">=", "68", ")", "AddQFloat", "=", "true", ";", "}", "else", "if", "(", "HvxVer", "==", "\"+hvx\"", ")", "{", "if", "(", "hasV68Ops", "(", ")", ")", "AddQFloat", "=", "true", ";", "}", "if", "(", "AddQFloat", ")", "Features", ".", "AddFeature", "(", "\"+hvx-qfloat\"", ")", ";", "}", "std", "::", "string", "FeatureString", "=", "Features", ".", "getString", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "CPUString", ",", "FeatureString", ")", ";", "bool", "GreaterThanV68", "=", "false", ";", "if", "(", "useHVXV69Ops", "(", ")", ")", "GreaterThanV68", "=", "true", ";", "if", "(", "!", "GreaterThanV68", ")", "{", "if", "(", "EnableV68FloatCodeGen", ")", "UseHVXFloatingPoint", "=", "true", ";", "}", "else", "{", "UseHVXFloatingPoint", "=", "true", ";", "}", "if", "(", "UseHVXQFloatOps", "&&", "UseHVXIEEEFPOps", "&&", "UseHVXFloatingPoint", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Behavior is undefined for simultaneous qfloat and ieee hvx codegen...\"", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "if", "(", "isTinyCore", "(", ")", ")", "{", "if", "(", "!", "EnableBSBSched", ".", "getPosition", "(", ")", ")", "UseBSBScheduling", "=", "false", ";", "}", "FeatureBitset", "FeatureBits", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "FeatureBits", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "FeatureBits", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "Hexagon::GetCpu", "Hexagon::CpuTable", "Hexagon", "\"Unrecognized Hexagon processor version\"", "\"+hvx-qfloat\"", "\"-hvx-qfloat\"", "\"+hvxv\"", "\"-hvx\"", "\"+hvx\"", "\"-hvx\"", "4", "\"+hvxv\"", "0", "5", "10", "68", "\"+hvx\"", "\"+hvx-qfloat\"", "\"Behavior is undefined for simultaneous qfloat and ieee hvx codegen...\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "if", "(", "EnableSDWAPeephole", ")", "{", "addPass", "(", "&", "SIPeepholeSDWAID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "bool", "ContiguousRegs", "=", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "unsigned", "*", "SuperReg", "=", "TRI", "->", "getSuperRegisters", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "SuperRegClass", "=", "0", ";", "assert", "(", "SuperReg", "[", "0", "]", "&&", "!", "SuperReg", "[", "1", "]", "&&", "\"Expected exactly one superreg\"", ")", ";", "bool", "CanUseDblLoad", "=", "false", ";", "if", "(", "ContiguousRegs", "&&", "(", "i", "<", "CSI", ".", "size", "(", ")", "-", "1", ")", ")", "{", "const", "unsigned", "*", "SuperRegNext", "=", "TRI", "->", "getSuperRegisters", "(", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ")", ";", "assert", "(", "SuperRegNext", "[", "0", "]", "&&", "!", "SuperRegNext", "[", "1", "]", "&&", "\"Expected exactly one superreg\"", ")", ";", "SuperRegClass", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "SuperReg", "[", "0", "]", ")", ";", "CanUseDblLoad", "=", "(", "SuperRegNext", "[", "0", "]", "==", "SuperReg", "[", "0", "]", ")", ";", "}", "if", "(", "CanUseDblLoad", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "SuperReg", "[", "0", "]", ",", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", ",", "SuperRegClass", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "SuperReg", "[", "0", "]", ")", ";", "++", "i", ";", "}", "else", "{", "ContiguousRegs", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "0", "0", "1", "\"Expected exactly one superreg\"", "1", "1", "0", "1", "\"Expected exactly one superreg\"", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "TOYMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "switch", "(", "MO", ".", "getReg", "(", ")", ")", "{", "case", "TOY", "::", "R0", ":", "return", "0", ";", "case", "TOY", "::", "R1", ":", "return", "1", ";", "case", "TOY", "::", "R2", ":", "return", "2", ";", "case", "TOY", "::", "R3", ":", "return", "3", ";", "case", "TOY", "::", "ZERO", ":", "return", "4", ";", "case", "TOY", "::", "SP", ":", "return", "5", ";", "case", "TOY", "::", "LR", ":", "return", "6", ";", "case", "TOY", "::", "TMP", ":", "return", "7", ";", "case", "TOY", "::", "PRED", ":", "return", "8", ";", "default", ":", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "assert", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "TOY", "::", "Fixups", "FixupKind", "=", "TOY", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_TOY_CALL", ":", "FixupKind", "=", "TOY", "::", "fixup_TOY_CALL", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_TOY_BR", ":", "FixupKind", "=", "TOY", "::", "fixup_TOY_BR", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::R0", "0", "TOY::R1", "1", "TOY::R2", "2", "TOY::R3", "3", "TOY::ZERO", "4", "TOY::SP", "5", "TOY::LR", "6", "TOY::TMP", "7", "TOY::PRED", "8", "\"Unable to encode MachineOperand!\"", "TOY::Fixups", "TOY::Fixups", "0", "\"Unknown fixup kind!\"", "TOY", "TOY::fixup_TOY_CALL", "TOY", "TOY::fixup_TOY_BR", "0", "\"Unable to encode MachineOperand!\"", "0" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "addInstSelector", "(", ")", "override", "{", "addPass", "(", "createPatmosISelDag", "(", "getPatmosTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorShiftByScalarCheap", "(", "Type", "*", "Ty", ")", "const", "{", "unsigned", "Bits", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "8", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "hasInt256", "(", ")", "&&", "(", "Bits", "==", "32", "||", "Bits", "==", "64", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "is", "used", "to", "enable", "splatted", "operand", "transforms", "for", "vector", "shifts", "and", "vector", "funnel", "shifts", "." ]

[ "X86", "X86", "8", "32", "64" ]

[]

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

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "GPR64RegClassID", ":", "case", "Mips", "::", "DSPRRegClassID", ":", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "28", "-", "TFI", "->", "hasFP", "(", "MF", ")", ";", "}", "case", "Mips", "::", "FGR32RegClassID", ":", "return", "32", ";", "case", "Mips", "::", "AFGR64RegClassID", ":", "return", "16", ";", "case", "Mips", "::", "FGR64RegClassID", ":", "return", "32", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::GPR32RegClassID", "Mips::GPR64RegClassID", "Mips::DSPRRegClassID", "28", "Mips::FGR32RegClassID", "32", "Mips::AFGR64RegClassID", "16", "Mips::FGR64RegClassID", "32" ]

[]

[ "<s>", "void", "clear", "(", ")", "{", "Bits", ".", "clear", "(", ")", ";", "LRU", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Hexagon" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "isImm", "(", "int64_t", "MinValue", ",", "int64_t", "MaxValue", ")", "const", "{", "return", "Kind", "==", "KindImm", "&&", "inRange", "(", "Imm", ",", "MinValue", ",", "MaxValue", ")", ";", "}", "</s>" ]

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

[ "RISCV" ]

[]

[ "<s>", "static", "int", "h8300_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "from", "==", "MAC_REGS", "||", "to", "==", "MAC_REG", ")", "return", "6", ";", "else", "return", "3", ";", "}", "</s>" ]

[ "Implements", "TARGET_REGISTER_MOVE_COST", ".", "Any", "SI", "register-to-register", "move", "may", "need", "to", "be", "reloaded", ",", "so", "inmplement", "h8300_register_move_cost", "to", "return", ">", "2", "so", "that", "reload", "never", "shortcuts", "." ]

[ "h8300", "6", "3" ]

[]

[ "<s>", "int", "zero_and_one", "(", "rtx", "operand1", ",", "rtx", "operand2", ")", "{", "return", "CONST_INT_P", "(", "operand1", ")", "&&", "CONST_INT_P", "(", "operand2", ")", "&&", "(", "(", "(", "INTVAL", "(", "operand1", ")", "==", "0", ")", "&&", "(", "INTVAL", "(", "operand2", ")", "==", "1", ")", ")", "||", "(", "(", "INTVAL", "(", "operand1", ")", "==", "1", ")", "&&", "(", "INTVAL", "(", "operand2", ")", "==", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "the", "constants", "0", "and", "1", "." ]

[ "m32r", "0", "1", "1", "0" ]

[]

[ "<s>", "DecodeStatus", "BPFDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "bool", "IsLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "uint64_t", "Insn", ",", "Hi", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableBPF64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Instr", ".", "getOpcode", "(", ")", ")", "{", "case", "BPF", "::", "LD_imm64", ":", "case", "BPF", "::", "LD_pseudo", ":", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "16", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "16", ";", "if", "(", "IsLittleEndian", ")", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "0", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "24", ")", ";", "else", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "0", ")", ";", "auto", "&", "Op", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "Op", ".", "setImm", "(", "Make_64", "(", "Hi", ",", "Op", ".", "getImm", "(", ")", ")", ")", ";", "break", ";", "}", "case", "BPF", "::", "LD_ABS_B", ":", "case", "BPF", "::", "LD_ABS_H", ":", "case", "BPF", "::", "LD_ABS_W", ":", "case", "BPF", "::", "LD_IND_B", ":", "case", "BPF", "::", "LD_IND_H", ":", "case", "BPF", "::", "LD_IND_W", ":", "{", "auto", "Op", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "Instr", ".", "clear", "(", ")", ";", "Instr", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "BPF", "::", "R6", ")", ")", ";", "Instr", ".", "addOperand", "(", "Op", ")", ";", "break", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF", "BPF::LD_imm64", "BPF::LD_pseudo", "16", "0", "16", "12", "0", "13", "8", "14", "16", "15", "24", "12", "24", "13", "16", "14", "8", "15", "0", "1", "BPF::LD_ABS_B", "BPF::LD_ABS_H", "BPF::LD_ABS_W", "BPF::LD_IND_B", "BPF::LD_IND_H", "BPF::LD_IND_W", "0", "BPF::R6" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "S2_storeri_io", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "case", "Hexagon", "::", "S2_storerb_io", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Hexagon", "Hexagon", "Hexagon::S2_storeri_io", "Hexagon::S2_storerd_io", "Hexagon::S2_storerh_io", "Hexagon::S2_storerb_io", "2", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "BPFTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "BPFPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "VETargetMachine", "::", "VETargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "std", "::", "string", "(", "CPU", ")", ",", "std", "::", "string", "(", "FS", ")", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "Aurora", "VE", "architecture", "model", "." ]

[ "VE", "VE", "VE" ]

[]

[ "<s>", "HOST_WIDE_INT", "const_vector_elt_as_int", "(", "rtx", "op", ",", "unsigned", "int", "elt", ")", "{", "rtx", "tmp", ";", "gcc_assert", "(", "GET_MODE", "(", "op", ")", "!=", "V2DImode", "&&", "GET_MODE", "(", "op", ")", "!=", "V2DFmode", ")", ";", "tmp", "=", "CONST_VECTOR_ELT", "(", "op", ",", "elt", ")", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "V4SFmode", ")", "tmp", "=", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ";", "return", "INTVAL", "(", "tmp", ")", ";", "}", "</s>" ]

[ "Interpret", "element", "ELT", "of", "the", "CONST_VECTOR", "OP", "as", "an", "integer", "value", ".", "If", "the", "mode", "of", "OP", "is", "MODE_VECTOR_INT", ",", "this", "simply", "returns", "the", "corresponding", "element", "of", "the", "vector", ",", "but", "for", "V4SFmode", ",", "the", "corresponding", "``", "float", "''", "is", "interpreted", "as", "an", "SImode", "integer", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "ldstwm_operation_p", "(", "rtx", "op", ",", "bool", "load_p", ")", "{", "int", "start", ",", "i", ",", "end", "=", "XVECLEN", "(", "op", ",", "0", ")", "-", "1", ",", "last_regno", "=", "-", "1", ";", "unsigned", "int", "regset", "=", "0", ";", "rtx", "base_reg", ",", "offset", ";", "rtx", "first_elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "bool", "inc_p", "=", "true", ";", "bool", "wb_p", "=", "base_reg_adjustment_p", "(", "first_elt", ",", "&", "base_reg", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "end", ")", ")", "==", "RETURN", ")", "end", "--", ";", "start", "=", "wb_p", "?", "1", ":", "0", ";", "for", "(", "i", "=", "start", ";", "i", "<=", "end", ";", "i", "++", ")", "{", "int", "regno", ";", "rtx", "reg", ",", "mem", ",", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "false", ";", "reg", "=", "load_p", "?", "SET_DEST", "(", "elt", ")", ":", "SET_SRC", "(", "elt", ")", ";", "mem", "=", "load_p", "?", "SET_SRC", "(", "elt", ")", ":", "SET_DEST", "(", "elt", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "!", "nios2_ldstwm_regset_p", "(", "regno", ",", "&", "regset", ")", ")", "return", "false", ";", "if", "(", "wb_p", ")", "inc_p", "=", "INTVAL", "(", "offset", ")", ">", "0", ";", "else", "if", "(", "i", "==", "start", ")", "{", "rtx", "first_base", ",", "first_offset", ";", "if", "(", "!", "split_mem_address", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "first_base", ",", "&", "first_offset", ")", ")", "return", "false", ";", "base_reg", "=", "first_base", ";", "inc_p", "=", "INTVAL", "(", "first_offset", ")", ">=", "0", ";", "}", "if", "(", "load_p", "&&", "regno", "==", "(", "int", ")", "REGNO", "(", "base_reg", ")", ")", "return", "false", ";", "if", "(", "last_regno", ">=", "0", ")", "{", "if", "(", "inc_p", "&&", "last_regno", ">=", "regno", ")", "return", "false", ";", "if", "(", "!", "inc_p", "&&", "last_regno", "<=", "regno", ")", "return", "false", ";", "}", "last_regno", "=", "regno", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Main", "function", "to", "implement", "ldwm_operation/stwm_operation", "predicates", "that", "check", "ldwm/stwm", "insn", "pattern", "integrity", "." ]

[ "nios2", "0", "1", "1", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "rs6000_output_savres_externs", "(", "FILE", "*", "file", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "debug_stack_info", "(", "info", ")", ";", "if", "(", "info", "->", "first_fp_reg_save", "<", "64", "&&", "!", "TARGET_MACHO", "&&", "!", "TARGET_ELF", ")", "{", "char", "*", "name", ";", "int", "regno", "=", "info", "->", "first_fp_reg_save", "-", "32", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "==", "0", ")", "{", "bool", "lr", "=", "(", "info", "->", "savres_strategy", "&", "SAVE_NOINLINE_FPRS_SAVES_LR", ")", "!=", "0", ";", "int", "sel", "=", "SAVRES_SAVE", "|", "SAVRES_FPR", "|", "(", "lr", "?", "SAVRES_LR", ":", "0", ")", ";", "name", "=", "rs6000_savres_routine_name", "(", "info", ",", "regno", ",", "sel", ")", ";", "fprintf", "(", "file", ",", "\"\\t.extern %s\\n\"", ",", "name", ")", ";", "}", "if", "(", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", "==", "0", ")", "{", "bool", "lr", "=", "(", "info", "->", "savres_strategy", "&", "REST_NOINLINE_FPRS_DOESNT_RESTORE_LR", ")", "==", "0", ";", "int", "sel", "=", "SAVRES_FPR", "|", "(", "lr", "?", "SAVRES_LR", ":", "0", ")", ";", "name", "=", "rs6000_savres_routine_name", "(", "info", ",", "regno", ",", "sel", ")", ";", "fprintf", "(", "file", ",", "\"\\t.extern %s\\n\"", ",", "name", ")", ";", "}", "}", "}", "</s>" ]

[ "Output", ".extern", "statements", "for", "the", "save/restore", "routines", "we", "use", "." ]

[ "rs6000", "64", "32", "0", "0", "0", "\"\\t.extern %s\\n\"", "0", "0", "0", "\"\\t.extern %s\\n\"" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "&&", "isHsaAbiVersion3AndAbove", "(", "getGlobalSTI", "(", ")", ")", ")", "{", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "return", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "STM", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "MFI", "->", "isEntryFunction", "(", ")", "&&", "STM", ".", "isAmdHsaOrMesa", "(", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "SmallString", "<", "128", ">", "SymbolName", ";", "getNameWithPrefix", "(", "SymbolName", ",", "&", "MF", "->", "getFunction", "(", ")", ")", ",", "getTargetStreamer", "(", ")", "->", "EmitAMDGPUSymbolType", "(", "SymbolName", ",", "ELF", "::", "STT_AMDGPU_HSA_KERNEL", ")", ";", "}", "if", "(", "DumpCodeInstEmitter", ")", "{", "DisasmLines", ".", "push_back", "(", "MF", "->", "getName", "(", ")", ".", "str", "(", ")", "+", "\":\"", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLines", ".", "back", "(", ")", ".", "size", "(", ")", ")", ";", "HexLines", ".", "push_back", "(", "\"\"", ")", ";", "}", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "128", "AMDGPU", "AMDGPU", "\":\"", "\"\"" ]

[]

[ "<s>", "bool", "HexagonSplitConst32AndConst64", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "auto", "&", "HST", "=", "Fn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HTM", "=", "static_cast", "<", "const", "HexagonTargetMachine", "&", ">", "(", "Fn", ".", "getTarget", "(", ")", ")", ";", "auto", "&", "TLOF", "=", "*", "HTM", ".", "getObjFileLowering", "(", ")", ";", "if", "(", "HST", ".", "useSmallData", "(", ")", "&&", "TLOF", ".", "isSmallDataEnabled", "(", ")", ")", "return", "false", ";", "const", "TargetInstrInfo", "*", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "Fn", ")", "{", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "++", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Hexagon", "::", "CONST32", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "uint64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestReg", ")", ".", "addImm", "(", "ImmValue", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "else", "if", "(", "Opc", "==", "Hexagon", "::", "CONST64", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "DestLo", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_lo", ")", ";", "unsigned", "DestHi", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_hi", ")", ";", "int32_t", "LowWord", "=", "(", "ImmValue", "&", "0xFFFFFFFF", ")", ";", "int32_t", "HighWord", "=", "(", "ImmValue", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestLo", ")", ".", "addImm", "(", "LowWord", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestHi", ")", ".", "addImm", "(", "HighWord", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::CONST32", "0", "1", "Hexagon::A2_tfrsi", "Hexagon::CONST64", "0", "1", "Hexagon::isub_lo", "Hexagon::isub_hi", "0xFFFFFFFF", "32", "0xFFFFFFFF", "Hexagon::A2_tfrsi", "Hexagon::A2_tfrsi" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "addPass", "(", "createFlattenCFGPass", "(", ")", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AttributeSet", "&", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "void", "spu_split_convert", "(", "rtx", "ops", "[", "]", ")", "{", "if", "(", "REGNO", "(", "ops", "[", "0", "]", ")", "==", "REGNO", "(", "ops", "[", "1", "]", ")", ")", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "else", "{", "rtx", "op0", "=", "gen_rtx_REG", "(", "TImode", ",", "REGNO", "(", "ops", "[", "0", "]", ")", ")", ";", "rtx", "op1", "=", "gen_rtx_REG", "(", "TImode", ",", "REGNO", "(", "ops", "[", "1", "]", ")", ")", ";", "emit_insn", "(", "gen_move_insn", "(", "op0", ",", "op1", ")", ")", ";", "}", "}", "</s>" ]

[ "After", "reload", ",", "just", "change", "the", "convert", "into", "a", "move", "instruction", "or", "a", "dead", "instruction", "." ]

[ "spu", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "void", "mn10300_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "const", "char", "*", "_this", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "_this", "=", "reg_names", "[", "FIRST_ARGUMENT_REGNUM", "+", "1", "]", ";", "else", "_this", "=", "reg_names", "[", "FIRST_ARGUMENT_REGNUM", "]", ";", "fprintf", "(", "file", ",", "\"\\t%s Thunk Entry Point:\\n\"", ",", "ASM_COMMENT_START", ")", ";", "if", "(", "delta", ")", "fprintf", "(", "file", ",", "\"\\tadd %d, %s\\n\"", ",", "(", "int", ")", "delta", ",", "_this", ")", ";", "if", "(", "vcall_offset", ")", "{", "const", "char", "*", "scratch", "=", "reg_names", "[", "FIRST_ADDRESS_REGNUM", "+", "1", "]", ";", "fprintf", "(", "file", ",", "\"\\tmov %s, %s\\n\"", ",", "_this", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov (%s), %s\\n\"", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd %d, %s\\n\"", ",", "(", "int", ")", "vcall_offset", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov (%s), %s\\n\"", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd %s, %s\\n\"", ",", "scratch", ",", "_this", ")", ";", "}", "fputs", "(", "\"\\tjmp \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "0", ")", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "}", "</s>" ]

[ "Output", "the", "assembler", "code", "for", "a", "C++", "thunk", "function", ".", "THUNK_DECL", "is", "the", "declaration", "for", "the", "thunk", "function", "itself", ",", "FUNCTION", "is", "the", "decl", "for", "the", "target", "function", ".", "DELTA", "is", "an", "immediate", "constant", "offset", "to", "be", "added", "to", "the", "THIS", "parameter", ".", "If", "VCALL_OFFSET", "is", "nonzero", "the", "word", "at", "the", "adjusted", "address", "*", "(", "*", "THIS", "'", "+", "VCALL_OFFSET", ")", "should", "be", "additionally", "added", "to", "THIS", ".", "Finally", "jump", "to", "the", "entry", "point", "of", "FUNCTION", "." ]

[ "mn10300", "1", "\"\\t%s Thunk Entry Point:\\n\"", "\"\\tadd %d, %s\\n\"", "1", "\"\\tmov %s, %s\\n\"", "\"\\tmov (%s), %s\\n\"", "\"\\tadd %d, %s\\n\"", "\"\\tmov (%s), %s\\n\"", "\"\\tadd %s, %s\\n\"", "\"\\tjmp \"", "0", "0" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "bool", "aarch64_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "return", "(", "reg_classes_intersect_p", "(", "FP_REGS", ",", "rclass", ")", "&&", "GET_MODE_SIZE", "(", "to", ")", "==", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "from", ")", ">", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "aarch64" ]

[]

[ "<s>", "static", "machine_mode", "c6x_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "return", "V2HImode", ";", "case", "E_QImode", ":", "return", "V4QImode", ";", "default", ":", "return", "word_mode", ";", "}", "}", "</s>" ]

[ "Implements", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "." ]

[ "c6x" ]

[]

[ "<s>", "static", "void", "filter_insns_above", "(", "basic_block", "bb", ",", "int", "max_uid", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "bool", "prev_ti", "=", "false", ";", "int", "prev_cycle", "=", "-", "1", ";", "FOR_BB_INSNS_SAFE", "(", "bb", ",", "insn", ",", "next", ")", "{", "int", "this_cycle", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "insn", "==", "BB_END", "(", "bb", ")", ")", "return", ";", "this_cycle", "=", "insn_get_clock", "(", "insn", ")", ";", "if", "(", "prev_ti", "&&", "this_cycle", "==", "prev_cycle", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "insn", ")", "!=", "TImode", ")", ";", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "}", "prev_ti", "=", "false", ";", "if", "(", "INSN_UID", "(", "insn", ")", ">=", "max_uid", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "{", "prev_ti", "=", "true", ";", "prev_cycle", "=", "this_cycle", ";", "}", "delete_insn", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Examine", "the", "insns", "in", "BB", "and", "remove", "all", "which", "have", "a", "uid", "greater", "or", "equal", "to", "MAX_UID", "." ]

[ "c6x", "1" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isIndirectCall", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "J2_callr", ":", "case", "Hexagon", "::", "J2_callrf", ":", "case", "Hexagon", "::", "J2_callrt", ":", "case", "Hexagon", "::", "PS_call_nr", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "callsite", "is", "an", "indirect", "call", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_callr", "Hexagon::J2_callrf", "Hexagon::J2_callrt", "Hexagon::PS_call_nr" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "addPass", "(", "createAArch64BranchFixupPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MachineInstr", "&", "ARMBaseInstrInfo", "::", "duplicate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "InsertBefore", ",", "const", "MachineInstr", "&", "Orig", ")", "const", "{", "MachineInstr", "&", "Cloned", "=", "TargetInstrInfo", "::", "duplicate", "(", "MBB", ",", "InsertBefore", ",", "Orig", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "Cloned", ".", "getIterator", "(", ")", ";", "for", "(", ";", ";", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CPI", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "I", "->", "getOperand", "(", "1", ")", ".", "setIndex", "(", "CPI", ")", ";", "I", "->", "getOperand", "(", "2", ")", ".", "setImm", "(", "PCLabelId", ")", ";", "break", ";", "}", "}", "if", "(", "!", "I", "->", "isBundledWithSucc", "(", ")", ")", "break", ";", "++", "I", ";", "}", "return", "Cloned", ";", "}", "</s>" ]

[ "Clones", "instruction", "or", "the", "whole", "instruction", "bundle", "Orig", "and", "insert", "into", "MBB", "before", "InsertBefore", "." ]

[ "ARM", "ARM", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1", "1", "2" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "const", "unsigned", "DefaultSafety", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "PPC", "::", "G8RC_NOX0RegClassID", ":", "case", "PPC", "::", "GPRC_NOR0RegClassID", ":", "case", "PPC", "::", "G8RCRegClassID", ":", "case", "PPC", "::", "GPRCRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "32", "-", "FP", "-", "DefaultSafety", ";", "}", "case", "PPC", "::", "F8RCRegClassID", ":", "case", "PPC", "::", "F4RCRegClassID", ":", "case", "PPC", "::", "QFRCRegClassID", ":", "case", "PPC", "::", "QSRCRegClassID", ":", "case", "PPC", "::", "QBRCRegClassID", ":", "case", "PPC", "::", "VRRCRegClassID", ":", "case", "PPC", "::", "VFRCRegClassID", ":", "case", "PPC", "::", "VSLRCRegClassID", ":", "return", "32", "-", "DefaultSafety", ";", "case", "PPC", "::", "VSRCRegClassID", ":", "case", "PPC", "::", "VSFRCRegClassID", ":", "case", "PPC", "::", "VSSRCRegClassID", ":", "return", "64", "-", "DefaultSafety", ";", "case", "PPC", "::", "CRRCRegClassID", ":", "return", "8", "-", "DefaultSafety", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "1", "0", "PPC::G8RC_NOX0RegClassID", "PPC::GPRC_NOR0RegClassID", "PPC::G8RCRegClassID", "PPC::GPRCRegClassID", "1", "0", "32", "PPC::F8RCRegClassID", "PPC::F4RCRegClassID", "PPC::QFRCRegClassID", "PPC::QSRCRegClassID", "PPC::QBRCRegClassID", "PPC::VRRCRegClassID", "PPC::VFRCRegClassID", "PPC::VSLRCRegClassID", "32", "PPC::VSRCRegClassID", "PPC::VSFRCRegClassID", "PPC::VSSRCRegClassID", "64", "PPC::CRRCRegClassID", "8" ]

[]

[ "<s>", "void", "Cpu0InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ",", "ZeroReg", "=", "0", ";", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Cpu0", "::", "ADD", ",", "ZeroReg", "=", "Cpu0", "::", "ZERO", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MFHI", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MFLO", ",", "SrcReg", "=", "0", ";", "}", "else", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "DestReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MTHI", ",", "DestReg", "=", "0", ";", "else", "if", "(", "DestReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MTLO", ",", "DestReg", "=", "0", ";", "}", "assert", "(", "Opc", "&&", "\"Cannot copy registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "ZeroReg", ")", "MIB", ".", "addReg", "(", "ZeroReg", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "0", "0", "Cpu0::CPURegsRegClass", "Cpu0::CPURegsRegClass", "Cpu0::ADD", "Cpu0::ZERO", "Cpu0::HI", "Cpu0::MFHI", "0", "Cpu0::LO", "Cpu0::MFLO", "0", "Cpu0::CPURegsRegClass", "Cpu0::HI", "Cpu0::MTHI", "0", "Cpu0::LO", "Cpu0::MTLO", "0", "\"Cannot copy registers\"" ]

[]

[ "<s>", "void", "ARMTargetStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ",", "char", "Suffix", ")", "{", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "getInstDesc", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "\"optionally flag setting instruction missing optional def operand\"", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "\"operand count mismatch!\"", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "0", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_MnemonicFail", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "isThumbOne", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "isThumbOne", "(", ")", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "ARM", "ARM", "ARMII::ThumbArithFlagSetting", "\"optionally flag setting instruction missing optional def operand\"", "\"operand count mismatch!\"", "0", "ARM::CPSR", "ARM::CPSR", "ARM::CPSR", "ARM::tADDhirr", "ARM", "1", "ARM", "2", "ARM::tMOVr", "ARM", "0", "ARM", "1" ]

[]

[ "<s>", "bool", "NyuziInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "true", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "!", "I", "->", "isTerminator", "(", ")", ")", "break", ";", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "I", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "return", "true", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "Nyuzi", "Nyuzi", "0", "\"FBB should have been null.\"", "1", "0" ]

[]

[ "<s>", "unsigned", "GCNHazardRecognizer", "::", "PreEmitNoops", "(", "MachineInstr", "*", "MI", ")", "{", "int", "WaitStates", "=", "std", "::", "max", "(", "0", ",", "checkAnyInstHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkSMRDHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkVALUHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkVMEMHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDPPHazards", "(", "MI", ")", ")", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkDivFMasHazards", "(", "MI", ")", ")", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "WaitStates", "=", "std", "::", "max", "(", "WaitStates", ",", "checkRWLaneHazards", "(", "MI", ")", ")", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkGetRegHazards", "(", "MI", ")", ")", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkSetRegHazards", "(", "MI", ")", ")", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkRFEHazards", "(", "MI", ")", ")", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkReadM0Hazards", "(", "MI", ")", ")", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "WaitStates", ",", "checkReadM0Hazards", "(", "MI", ")", ")", ";", "return", "WaitStates", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

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

[]

[ "<s>", "static", "bool", "s390_valid_target_attribute_p", "(", "tree", "fndecl", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "args", ",", "int", "ARG_UNUSED", "(", "flags", ")", ")", "{", "struct", "gcc_options", "func_options", ",", "func_options_set", ";", "tree", "new_target", ",", "new_optimize", ";", "bool", "ret", "=", "true", ";", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", "&&", "TREE_CHAIN", "(", "args", ")", "==", "NULL_TREE", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ",", "\"default\"", ")", "==", "0", ")", "return", "true", ";", "tree", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "!", "func_optimize", ")", "func_optimize", "=", "old_optimize", ";", "memset", "(", "&", "func_options", ",", "0", ",", "sizeof", "(", "func_options", ")", ")", ";", "init_options_struct", "(", "&", "func_options", ",", "NULL", ")", ";", "lang_hooks", ".", "init_options_struct", "(", "&", "func_options", ")", ";", "memset", "(", "&", "func_options_set", ",", "0", ",", "sizeof", "(", "func_options_set", ")", ")", ";", "cl_optimization_restore", "(", "&", "func_options", ",", "&", "func_options_set", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_restore", "(", "&", "func_options", ",", "&", "func_options_set", ",", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ")", ";", "new_target", "=", "s390_valid_target_attribute_tree", "(", "args", ",", "&", "func_options", ",", "&", "global_options_set", ",", "(", "args", "==", "current_target_pragma", ")", ")", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "func_options", ",", "&", "func_options_set", ")", ";", "if", "(", "new_target", "==", "error_mark_node", ")", "ret", "=", "false", ";", "else", "if", "(", "fndecl", "&&", "new_target", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "attribute", "(", "(", "target", "(", "``", "string", "''", ")", ")", ")", "." ]

[ "s390", "\"default\"", "0", "0", "0" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "And", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "==", "64", "&&", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "ICmp", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "(", "BitSize", "+", "63", ")", "/", "64", ";", "int", "Cost", "=", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "return", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "X86", "X86", "0", "0U", "0", "2", "0", "1", "64", "32", "1", "1", "63", "64", "X86", "X86" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Optimize addressing mode of load/store\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Optimize addressing mode of load/store\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_SaveList", ":", "CSR_SVR32_ColdCC_SaveList", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "(", "SaveR2", "?", "CSR_SVR464_R2_Altivec_SaveList", ":", "CSR_SVR464_Altivec_SaveList", ")", ":", "(", "SaveR2", "?", "CSR_SVR464_R2_SaveList", ":", "CSR_SVR464_SaveList", ")", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "JVMRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "JVM", "JVM", "0" ]

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Kind", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "int64_t", "SignedValue", "=", "static_cast", "<", "int64_t", ">", "(", "Value", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "Ctx", ",", "TheTriple", ",", "IsResolved", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "if", "(", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "==", "AArch64MCExpr", "::", "VK_SABS", "||", "(", "!", "RefKind", "&&", "Fixup", ".", "getTargetKind", "(", ")", "==", "AArch64", "::", "fixup_aarch64_movw", ")", ")", "{", "if", "(", "SignedValue", "<", "0", ")", "Data", "[", "Offset", "+", "3", "]", "&=", "~", "(", "1", "<<", "6", ")", ";", "else", "Data", "[", "Offset", "+", "3", "]", "|=", "(", "1", "<<", "6", ")", ";", "}", "}", "</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", "." ]

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::fixup_aarch64_movw", "0", "3", "1", "6", "3", "1", "6" ]

[]

[ "<s>", "unsigned", "AMDGPUIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "Len", ")", "const", "{", "if", "(", "!", "StringRef", "(", "Name", ",", "Len", ")", ".", "startswith", "(", "\"llvm.\"", ")", ")", "return", "0", ";", "AMDGPUIntrinsic", "::", "ID", "IntrinsicID", "=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ";", "IntrinsicID", "=", "getIntrinsicForGCCBuiltin", "(", "\"AMDGPU\"", ",", "Name", ")", ";", "if", "(", "IntrinsicID", "!=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ")", "{", "return", "IntrinsicID", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "R600", "\"llvm.\"", "0", "AMDGPUIntrinsic::ID", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "\"AMDGPU\"", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "0" ]

[]

[ "<s>", "bool", "MOSTargetLowering", "::", "isZExtFree", "(", "Type", "*", "SrcTy", ",", "Type", "*", "DstTy", ")", "const", "{", "if", "(", "!", "SrcTy", "->", "isIntegerTy", "(", ")", "||", "!", "DstTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "return", "SrcTy", "->", "getPrimitiveSizeInBits", "(", ")", "<", "DstTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "isReachable", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "PatmosSinglePathInfo", "::", "isReachable", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "instruction", "is", "reachable", "from", "entry", "." ]

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "ix86_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "f", ";", "f", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "f", "->", "call_abi", "=", "ix86_abi", ";", "return", "f", ";", "}", "</s>" ]

[ "Clear", "stack", "slot", "assignments", "remembered", "from", "previous", "functions", ".", "This", "is", "called", "from", "INIT_EXPANDERS", "once", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "i386" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "SrcReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_0", ",", "getKillRegState", "(", "isKill", ")", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_1", ",", "0", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2STRi12", "0", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2STRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "0", "ARM" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "hasReservedCallFrame", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "12", ")", "-", "1", ")", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "ARM", "1", "12", "1", "2" ]

[]

[ "<s>", "static", "void", "paired_emit_vector_compare", "(", "enum", "rtx_code", "rcode", ",", "rtx", "dest", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "rtx", "tmp1", ",", "max", ",", "min", ";", "gcc_assert", "(", "TARGET_PAIRED_FLOAT", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "op0", ")", "==", "GET_MODE", "(", "op1", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "LT", ":", "case", "LTU", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "GE", ":", "case", "GEU", ":", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op0", ",", "cc_op1", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "dest", ",", "tmp", ",", "op0", ",", "op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "return", ";", "case", "LE", ":", "case", "LEU", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op0", ",", "op1", ",", "cc_op1", ",", "cc_op0", ")", ";", "return", ";", "case", "GT", ":", "paired_emit_vector_compare", "(", "LE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "EQ", ":", "tmp1", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "max", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "min", "=", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "gen_reg_rtx", "(", "V2SFmode", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op0", ",", "cc_op1", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "max", ",", "tmp", ",", "cc_op0", ",", "cc_op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp", ",", "cc_op1", ",", "cc_op0", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "min", ",", "tmp", ",", "cc_op0", ",", "cc_op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "emit_insn", "(", "gen_subv2sf3", "(", "tmp1", ",", "min", ",", "max", ")", ")", ";", "emit_insn", "(", "gen_selv2sf4", "(", "dest", ",", "tmp1", ",", "op0", ",", "op1", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ")", ";", "return", ";", "case", "NE", ":", "paired_emit_vector_compare", "(", "EQ", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNLE", ":", "paired_emit_vector_compare", "(", "LE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNLT", ":", "paired_emit_vector_compare", "(", "LT", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNGE", ":", "paired_emit_vector_compare", "(", "GE", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "case", "UNGT", ":", "paired_emit_vector_compare", "(", "GT", ",", "dest", ",", "op1", ",", "op0", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Emit", "vector", "compare", "for", "code", "RCODE", ".", "DEST", "is", "destination", ",", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ",", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", ".", "This", "is", "a", "recursive", "function", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "insn_terminates_group_p", "(", "rtx_insn", "*", "insn", ",", "enum", "group_termination", "which_group", ")", "{", "bool", "first", ",", "last", ";", "if", "(", "!", "insn", ")", "return", "false", ";", "first", "=", "insn_must_be_first_in_group", "(", "insn", ")", ";", "last", "=", "insn_must_be_last_in_group", "(", "insn", ")", ";", "if", "(", "first", "&&", "last", ")", "return", "true", ";", "if", "(", "which_group", "==", "current_group", ")", "return", "last", ";", "else", "if", "(", "which_group", "==", "previous_group", ")", "return", "first", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "the", "presence", "of", "INSN", "causes", "a", "dispatch", "group", "termination", "of", "group", "WHICH_GROUP", ".", "If", "WHICH_GROUP", "==", "current_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "current", "group", "(", "i.e", ",", "the", "dispatch", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "last", "insn", "in", "the", "group", "it", "belongs", "to", ".", "If", "WHICH_GROUP", "==", "previous_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "previous", "group", "(", "i.e", ",", "the", "dispatch", "group", "that", "precedes", "the", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "first", "insn", "in", "the", "group", "it", "belongs", "to", ")", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "ix86_emit_fp_unordered_jump", "(", "rtx", "label", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "temp", ";", "emit_insn", "(", "gen_x86_fnstsw_1", "(", "reg", ")", ")", ";", "if", "(", "TARGET_USE_SAHF", ")", "{", "emit_insn", "(", "gen_x86_sahf_1", "(", "reg", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_UNORDERED", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_testqi_ext_ccno_0", "(", "reg", ",", "GEN_INT", "(", "0x04", ")", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "temp", ")", ";", "emit_jump_insn", "(", "temp", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "conditional", "jump", "to", "LABEL", ",", "if", "C2", "flag", "in", "FP", "status", "register", "is", "set", "." ]

[ "i386", "0x04" ]

[]

[ "<s>", "static", "void", "mmix_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "ffs_optab", ",", "SImode", ",", "\"__ffsdi2\"", ")", ";", "}", "</s>" ]

[ "Unfortunately", ",", "by", "default", "__builtin_ffs", "is", "expanded", "to", "ffs", "for", "targets", "where", "INT_TYPE_SIZE", "<", "BITS_PER_WORD", ".", "That", "together", "with", "newlib", "since", "2017-07-04", "implementing", "ffs", "as", "__builtin_ffs", "leads", "to", "(", "newlib", ")", "ffs", "recursively", "calling", "itself", ".", "But", ",", "because", "of", "argument", "promotion", ",", "and", "with", "ffs", "we", "'re", "counting", "from", "the", "least", "bit", ",", "the", "libgcc", "equivalent", "for", "ffsl", "works", "equally", "well", "for", "int", "arguments", ",", "so", "just", "use", "that", "." ]

[ "mmix", "\"__ffsdi2\"" ]

[]

[ "<s>", "void", "arc_secondary_reload_conv", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "emit_move_insn", "(", "scratch", ",", "addr", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Convert", "reloads", "using", "offsets", "that", "are", "too", "large", "to", "use", "indirect", "addressing", "." ]

[ "arc", "0" ]

[]

[ "<s>", "DecodeStatus", "LanaiDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableLanai32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "PostOperandDecodeAdjust", "(", "Instr", ",", "Insn", ")", ";", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPULowerIntrinsics", "::", "makeLIDRangeMetadata", "(", "Function", "&", "F", ")", "const", "{", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "U", ":", "F", ".", "users", "(", ")", ")", "{", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ")", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Caller", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "TM", ",", "*", "Caller", ")", ";", "Changed", "|=", "ST", ".", "makeLIDRangeMetadata", "(", "CI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Creates", "value", "range", "metadata", "on", "an", "workitemid", ".", "*", "intrinsic", "call", "or", "load", "." ]

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

[]

[ "<s>", "unsigned", "TMS320C64XInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "TargetInstrDesc", "desc", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "desc", ".", "TSFlags", "&", "TMS320C64XII", "::", "is_memaccess", "&&", "desc", ".", "TSFlags", "&", "TMS320C64XII", "::", "is_store", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "TMS320C64X", "::", "B15", ")", "{", "MachineOperand", "op", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "op", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "op", ".", "getIndex", "(", ")", ";", "return", "true", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Found store-to-stack sans \"", "\"frame index operand\"", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "TMS320C64X", "TMS320C64X", "TMS320C64XII::is_memaccess", "TMS320C64XII::is_store", "0", "TMS320C64X::B15", "1", "\"Found store-to-stack sans \"", "\"frame index operand\"" ]

[]

[ "<s>", "bool", "mcore_gen_compare", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "cc_reg", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REG", ")", ";", "bool", "invert", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "op1", ")", ";", "switch", "(", "code", ")", "{", "case", "GTU", ":", "if", "(", "val", "==", "0", ")", "code", "=", "NE", ";", "break", ";", "case", "GT", ":", "case", "LE", ":", "if", "(", "CONST_OK_FOR_J", "(", "val", "+", "1", ")", ")", "{", "op1", "=", "GEN_INT", "(", "val", "+", "1", ")", ";", "code", "=", "code", "==", "LE", "?", "LT", ":", "GE", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "CONSTANT_P", "(", "op1", ")", "&&", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "invert", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "code", "=", "NE", ";", "invert", "=", "true", ";", "case", "NE", ":", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "!", "CONST_OK_FOR_K", "(", "INTVAL", "(", "op1", ")", ")", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "break", ";", "case", "LE", ":", "code", "=", "GT", ";", "invert", "=", "true", ";", "case", "GT", ":", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "break", ";", "case", "GE", ":", "code", "=", "LT", ";", "invert", "=", "true", ";", "case", "LT", ":", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "!=", "0", "&&", "!", "CONST_OK_FOR_J", "(", "INTVAL", "(", "op1", ")", ")", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "break", ";", "case", "GTU", ":", "gcc_assert", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op1", ")", "!=", "0", ")", ";", "code", "=", "LEU", ";", "invert", "=", "true", ";", "case", "LEU", ":", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "!=", "0", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "break", ";", "case", "LTU", ":", "code", "=", "GEU", ";", "invert", "=", "true", ";", "case", "GEU", ":", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "!=", "0", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "break", ";", "default", ":", "break", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_fmt_ee", "(", "code", ",", "CCmode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "invert", ";", "}", "</s>" ]

[ "Prepare", "the", "operands", "for", "a", "comparison", ".", "Return", "whether", "the", "branch/setcc", "should", "reverse", "the", "operands", "." ]

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

[]

[ "<s>", "static", "bool", "arm_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "base", ")", ")", "{", "if", "(", "(", "SYMBOL_REF_FLAGS", "(", "base", ")", "&", "SYMBOL_FLAG_FUNCTION", ")", "&&", "INTVAL", "(", "offset", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "ARM_OFFSETS_MUST_BE_WITHIN_SECTIONS_P", "&&", "!", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", ")", ")", "return", "true", ";", "}", "return", "arm_tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "arm", "0" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "this", ",", "Name", ",", "NameLoc", ")", ")", ";", "bool", "IsMIMG", "=", "Name", ".", "startswith", "(", "\"image_\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "OperandMode", "Mode", "=", "OperandMode_Default", ";", "if", "(", "IsMIMG", "&&", "isGFX10", "(", ")", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "Mode", "=", "OperandMode_NSA", ";", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ",", "Mode", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "{", "checkUnsupportedInstruction", "(", "Name", ",", "NameLoc", ")", ";", "if", "(", "!", "Parser", ".", "hasPendingError", "(", ")", ")", "{", "StringRef", "Msg", "=", "(", "Res", "==", "MatchOperand_ParseFail", ")", "?", "\"failed parsing operand.\"", ":", "\"not a valid operand.\"", ";", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "Msg", ")", ";", "}", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "\"image_\"", "2", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isAlwaysUniform", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_readfirstlane", ":", "case", "Intrinsic", "::", "amdgcn_readlane", ":", "case", "Intrinsic", "::", "amdgcn_icmp", ":", "case", "Intrinsic", "::", "amdgcn_fcmp", ":", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Whether", "Val", "will", "always", "return", "a", "uniform", "value", "regardless", "of", "its", "operands", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_readfirstlane", "Intrinsic::amdgcn_readlane", "Intrinsic::amdgcn_icmp", "Intrinsic::amdgcn_fcmp" ]

[]

[ "<s>", "int", "mcore_is_same_reg", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "while", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "while", "(", "GET_CODE", "(", "y", ")", "==", "SUBREG", ")", "y", "=", "SUBREG_REG", "(", "y", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "GET_CODE", "(", "y", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", "==", "REGNO", "(", "y", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Tell", "me", "if", "a", "pair", "of", "reg/subreg", "rtx", "'s", "actually", "refer", "to", "the", "same", "register", ".", "Note", "that", "the", "current", "version", "does", "n't", "worry", "about", "whether", "they", "are", "the", "same", "mode", "or", "note", "(", "e.g.", ",", "a", "QImode", "in", "r2", "matches", "an", "HImode", "in", "r2", "matches", "an", "SImode", "in", "r2", ".", "Might", "think", "in", "the", "future", "about", "whether", "we", "want", "to", "be", "able", "to", "say", "something", "about", "modes", "." ]

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

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getMcpu", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "MCPU_970", ":", "case", "PPC", "::", "MCPU_PWR4", ":", "case", "PPC", "::", "MCPU_PWR5", ":", "case", "PPC", "::", "MCPU_PWR5X", ":", "case", "PPC", "::", "MCPU_PWR6", ":", "case", "PPC", "::", "MCPU_PWR6X", ":", "case", "PPC", "::", "MCPU_PWR7", ":", "case", "PPC", "::", "MCPU_PWR8", ":", "case", "PPC", "::", "MCPU_PWR9", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "5", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::MCPU_970", "PPC::MCPU_PWR4", "PPC::MCPU_PWR5", "PPC::MCPU_PWR5X", "PPC::MCPU_PWR6", "PPC::MCPU_PWR6X", "PPC::MCPU_PWR7", "PPC::MCPU_PWR8", "PPC::MCPU_PWR9", "PPC", "0", "32", "16", "32", "5" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "SW", ":", "RISCV", "::", "SD", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSD", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::SW", "RISCV::SD", "RISCV::FPR32RegClass", "RISCV::FSW", "RISCV::FPR64RegClass", "RISCV::FSD", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "{", "PM", ".", "add", "(", "createHexagonFixupHwLoops", "(", ")", ")", ";", "}", "PM", ".", "add", "(", "createHexagonExpandPredSpillCode", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "PM", ".", "add", "(", "createHexagonSplitTFRCondSets", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "arc_label_align", "(", "rtx_insn", "*", "label", ")", "{", "int", "loop_align", "=", "LOOP_ALIGN", "(", "LABEL", ")", ";", "if", "(", "loop_align", ">", "align_labels_log", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "label", ")", ";", "if", "(", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "PARALLEL", "&&", "recog_memoized", "(", "prev", ")", "==", "CODE_FOR_doloop_begin_i", ")", "return", "loop_align", ";", "}", "if", "(", "align_labels_log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels_log", ";", "}", "</s>" ]

[ "Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")" ]

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

[]

[ "<s>", "static", "bool", "aapcs_vfp_allocate", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ")", "{", "int", "rmode_size", "=", "MAX", "(", "GET_MODE_SIZE", "(", "pcum", "->", "aapcs_vfp_rmode", ")", ",", "GET_MODE_SIZE", "(", "SFmode", ")", ")", ";", "int", "shift", "=", "rmode_size", "/", "GET_MODE_SIZE", "(", "SFmode", ")", ";", "unsigned", "mask", "=", "(", "1", "<<", "(", "shift", "*", "pcum", "->", "aapcs_vfp_rcount", ")", ")", "-", "1", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "NUM_VFP_ARG_REGS", ";", "regno", "+=", "shift", ")", "if", "(", "(", "(", "pcum", "->", "aapcs_vfp_regs_free", ">>", "regno", ")", "&", "mask", ")", "==", "mask", ")", "{", "pcum", "->", "aapcs_vfp_reg_alloc", "=", "mask", "<<", "regno", ";", "if", "(", "mode", "==", "BLKmode", "||", "(", "mode", "==", "TImode", "&&", "!", "(", "TARGET_NEON", "||", "TARGET_HAVE_MVE", ")", ")", "||", "!", "arm_hard_regno_mode_ok", "(", "FIRST_VFP_REGNUM", "+", "regno", ",", "mode", ")", ")", "{", "int", "i", ";", "int", "rcount", "=", "pcum", "->", "aapcs_vfp_rcount", ";", "int", "rshift", "=", "shift", ";", "machine_mode", "rmode", "=", "pcum", "->", "aapcs_vfp_rmode", ";", "rtx", "par", ";", "if", "(", "!", "(", "TARGET_NEON", "||", "TARGET_HAVE_MVE", ")", ")", "{", "if", "(", "rmode", "==", "V2SImode", ")", "rmode", "=", "DImode", ";", "else", "if", "(", "rmode", "==", "V4SImode", ")", "{", "rmode", "=", "DImode", ";", "rcount", "*=", "2", ";", "rshift", "/=", "2", ";", "}", "}", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "rcount", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "rcount", ";", "i", "++", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "rmode", ",", "FIRST_VFP_REGNUM", "+", "regno", "+", "i", "*", "rshift", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "GEN_INT", "(", "i", "*", "GET_MODE_SIZE", "(", "rmode", ")", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "tmp", ";", "}", "pcum", "->", "aapcs_reg", "=", "par", ";", "}", "else", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "FIRST_VFP_REGNUM", "+", "regno", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "the", "allocate", "field", "in", "aapcs_cp_arg_layout", ".", "See", "the", "comment", "there", "for", "the", "behaviour", "of", "this", "function", "." ]

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

[]

[ "<s>", "bool", "PIC16Overlay", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "CallGraph", "&", "CG", "=", "getAnalysis", "<", "CallGraph", ">", "(", ")", ";", "CallGraphNode", "*", "ECN", "=", "CG", ".", "getExternalCallingNode", "(", ")", ";", "MarkIndirectlyCalledFunctions", "(", "M", ")", ";", "if", "(", "ECN", ")", "{", "DFSTraverse", "(", "ECN", ",", "0", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "0" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "16", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "VT", "==", "MVT", "::", "v64i1", "&&", "Subtarget", ".", "hasBWI", "(", ")", "&&", "!", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "CC", "!=", "CallingConv", "::", "X86_RegCall", ")", "return", "MVT", "::", "v32i1", ";", "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "!", "EnableOldKNLABI", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v16i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::v32i1", "MVT::v32i8", "MVT::i1", "16", "64", "MVT::i8", "MVT::v64i1", "X86", "MVT::v32i1", "MVT::v32i16", "MVT::v64i8", "MVT::v16i32" ]

[]

[ "<s>", "void", "addLOHDirective", "(", "MCLOHType", "Kind", ",", "const", "MILOHArgs", "&", "Args", ")", "{", "LOHContainerSet", ".", "push_back", "(", "MILOHDirective", "(", "Kind", ",", "Args", ")", ")", ";", "LOHRelated", ".", "insert", "(", "Args", ".", "begin", "(", ")", ",", "Args", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "LOH", "directive", "of", "this", "Kind", "and", "this", "Args", "." ]

[ "ARM64" ]

[]