Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "ix86_force_to_memory", "(", "enum", "machine_mode", "mode", ",", "rtx", "operand", ")", "{", "rtx", "result", ";", "gcc_assert", "(", "reload_completed", ")", ";", "if", "(", "TARGET_RED_ZONE", ")", "{", "result", "=", "gen_rtx_MEM", "(", "mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "RED_ZONE_SIZE", ")", ")", ")", ";", "emit_move_insn", "(", "result", ",", "operand", ")", ";", "}", "else", "if", "(", "!", "TARGET_RED_ZONE", "&&", "TARGET_64BIT", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "case", "SImode", ":", "operand", "=", "gen_lowpart", "(", "DImode", ",", "operand", ")", ";", "case", "DImode", ":", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "DImode", ",", "gen_rtx_PRE_DEC", "(", "DImode", ",", "stack_pointer_rtx", ")", ")", ",", "operand", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "result", "=", "gen_rtx_MEM", "(", "mode", ",", "stack_pointer_rtx", ")", ";", "}", "else", "{", "switch", "(", "mode", ")", "{", "case", "DImode", ":", "{", "rtx", "operands", "[", "2", "]", ";", "split_di", "(", "&", "operand", ",", "1", ",", "operands", ",", "operands", "+", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "operands", "[", "1", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "operands", "[", "0", "]", ")", ")", ";", "}", "break", ";", "case", "HImode", ":", "operand", "=", "gen_lowpart", "(", "SImode", ",", "operand", ")", ";", "case", "SImode", ":", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "GET_MODE", "(", "operand", ")", ",", "gen_rtx_PRE_DEC", "(", "SImode", ",", "stack_pointer_rtx", ")", ")", ",", "operand", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "result", "=", "gen_rtx_MEM", "(", "mode", ",", "stack_pointer_rtx", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Store", "OPERAND", "to", "the", "memory", "after", "reload", "is", "completed", ".", "This", "means", "that", "we", "ca", "n't", "easily", "use", "assign_stack_local", "." ]

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

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "IsSlowLEA", "=", "ST", ".", "slowLEA", "(", ")", ";", "bool", "IsSlow3OpsLEA", "=", "ST", ".", "slow3OpsLEA", "(", ")", ";", "bool", "LEAUsesAG", "=", "ST", ".", "leaUsesAG", "(", ")", ";", "bool", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "bool", "UseLEAForSP", "=", "ST", ".", "useLeaForSP", "(", ")", ";", "TSM", ".", "init", "(", "&", "ST", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "auto", "*", "PSI", "=", "&", "getAnalysis", "<", "ProfileSummaryInfoWrapperPass", ">", "(", ")", ".", "getPSI", "(", ")", ";", "auto", "*", "MBFI", "=", "(", "PSI", "&&", "PSI", "->", "hasProfileSummary", "(", ")", ")", "?", "&", "getAnalysis", "<", "LazyMachineBlockFrequencyInfoPass", ">", "(", ")", ".", "getBFI", "(", ")", ":", "nullptr", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "OptIncDecPerBB", "=", "OptIncDec", "||", "llvm", "::", "shouldOptimizeForSize", "(", "&", "MBB", ",", "PSI", ",", "MBFI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "isLEA", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "optTwoAddrLEA", "(", "I", ",", "MBB", ",", "OptIncDecPerBB", ",", "UseLEAForSP", ")", ")", "continue", ";", "if", "(", "IsSlowLEA", ")", "processInstructionForSlowLEA", "(", "I", ",", "MBB", ")", ";", "else", "if", "(", "IsSlow3OpsLEA", ")", "processInstrForSlow3OpLEA", "(", "I", ",", "MBB", ",", "OptIncDecPerBB", ")", ";", "}", "if", "(", "LEAUsesAG", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "processInstruction", "(", "I", ",", "MBB", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "Hexagon", "::", "ArchEnum", "::", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "\"hexagonv65\"", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60TOps", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "set", "(", "Hexagon", "::", "FeatureDuplex", ",", "false", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "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", "\"hexagonv4\"", "Hexagon::ArchEnum", "\"hexagonv5\"", "Hexagon::ArchEnum", "\"hexagonv55\"", "Hexagon::ArchEnum", "\"hexagonv60\"", "Hexagon::ArchEnum", "\"hexagonv62\"", "Hexagon::ArchEnum", "\"hexagonv65\"", "Hexagon::ArchEnum", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "int", "microblaze_expand_shift", "(", "rtx", "operands", "[", "]", ")", "{", "gcc_assert", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "SUBREG", ")", ")", ";", "if", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "==", "1", ")", ")", "return", "0", ";", "if", "(", "TARGET_BARREL_SHIFT", ")", "return", "0", ";", "gcc_assert", "(", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", ")", "||", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "SUBREG", ")", "||", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", ")", "||", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SUBREG", ")", ")", ";", "if", "(", "operands", "[", "2", "]", "==", "const0_rtx", "&&", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "emit_insn", "(", "gen_movsi", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Expand", "shift", "operations", "." ]

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

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "CmpMask", ",", "int64_t", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Lanai", "::", "SFSUB_F_RI_LO", ":", "case", "Lanai", "::", "SFSUB_F_RI_HI", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "Register", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "Lanai", "::", "SFSUB_F_RR", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "Lanai", "Lanai", "Lanai::SFSUB_F_RI_LO", "Lanai::SFSUB_F_RI_HI", "0", "0", "1", "Lanai::SFSUB_F_RR", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "load_pic_register", "(", "bool", "delay_pic_helper", "ATTRIBUTE_UNUSED", ")", "{", "int", "orig_flag_pic", "=", "flag_pic", ";", "rtx", "got_symbol", "=", "tilepro_got_symbol", "(", ")", ";", "rtx", "text_label_symbol", "=", "tilepro_text_label_symbol", "(", ")", ";", "rtx", "text_label_rtx", "=", "tilepro_text_label_rtx", "(", ")", ";", "flag_pic", "=", "0", ";", "emit_insn", "(", "gen_insn_lnk_and_label", "(", "text_label_rtx", ",", "text_label_symbol", ")", ")", ";", "emit_insn", "(", "gen_addli_pcrel", "(", "tilepro_got_rtx", "(", ")", ",", "text_label_rtx", ",", "got_symbol", ",", "text_label_symbol", ")", ")", ";", "emit_insn", "(", "gen_auli_pcrel", "(", "tilepro_got_rtx", "(", ")", ",", "tilepro_got_rtx", "(", ")", ",", "got_symbol", ",", "text_label_symbol", ")", ")", ";", "flag_pic", "=", "orig_flag_pic", ";", "emit_use", "(", "tilepro_got_rtx", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "load", "the", "PIC", "register", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "bool", "aarch64_sve_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "aarch64_classify_vector_mode", "(", "mode", ")", "&", "VEC_ANY_SVE", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "any", "form", "of", "SVE", "mode", ",", "including", "predicates", ",", "vectors", "and", "structures", "." ]

[ "aarch64" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680x0 PIC Global Base Reg Initialization\"", ";", "}", "</s>" ]

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

[ "M680x0", "\"M680x0 PIC Global Base Reg Initialization\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PIC16 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "PIC16", "\"PIC16 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "bool", "SparcDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectADDRrr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectADDRri", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

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

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

[ "Teak" ]

[]

[ "<s>", "static", "int", "loongarch_move_to_gpr_cost", "(", "reg_class_t", "from", ")", "{", "switch", "(", "from", ")", "{", "case", "GENERAL_REGS", ":", "return", "2", ";", "case", "FP_REGS", ":", "return", "4", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "a", "value", "from", "a", "register", "of", "class", "FROM", "to", "a", "GPR", ".", "Return", "0", "for", "classes", "that", "are", "unions", "of", "other", "classes", "handled", "by", "this", "function", "." ]

[ "loongarch", "2", "4", "0" ]

[]

[ "<s>", "bool", "isDefined", "(", ")", "{", "return", "Inst2Replace", "!=", "nullptr", ";", "}", "</s>" ]

[ "isDefined", "-", "Check", "if", "this", "symbol", "is", "defined", "(", "i.e.", ",", "it", "has", "an", "address", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v4i32", "||", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "MVT::v4i32", "MVT::v8i16", "MVT::v16i8", "MVT::getVectorVT", "MVT::i1" ]

[]

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

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

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

[]

[ "<s>", "bool", "function_resolver", "::", "require_derived_scalar_type", "(", "unsigned", "int", "argno", ",", "type_class_index", "expected_tclass", ",", "unsigned", "int", "expected_bits", ")", "{", "gcc_assert", "(", "expected_tclass", "==", "SAME_TYPE_CLASS", "||", "expected_tclass", "==", "TYPE_signed", "||", "expected_tclass", "==", "TYPE_unsigned", ")", ";", "if", "(", "expected_tclass", "!=", "SAME_TYPE_CLASS", "&&", "expected_bits", "!=", "SAME_SIZE", ")", "{", "type_suffix_index", "expected_type", "=", "find_type_suffix", "(", "expected_tclass", ",", "expected_bits", ")", ";", "return", "require_scalar_type", "(", "argno", ",", "get_scalar_type_name", "(", "expected_type", ")", ")", ";", "}", "if", "(", "scalar_argument_p", "(", "argno", ")", ")", "return", "true", ";", "if", "(", "expected_tclass", "==", "SAME_TYPE_CLASS", ")", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a scalar element\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "else", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a scalar integer\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "(", "possibly", "variable", ")", "scalar", ",", "expecting", "it", "to", "have", "the", "following", "properties", ":", "-", "the", "type", "class", "must", "be", "the", "same", "as", "for", "type", "suffix", "0", "if", "EXPECTED_TCLASS", "is", "SAME_TYPE_CLASS", ",", "otherwise", "it", "must", "be", "EXPECTED_TCLASS", "itself", ".", "-", "the", "element", "size", "must", "be", "the", "same", "as", "for", "type", "suffix", "0", "if", "EXPECTED_BITS", "is", "SAME_TYPE_SIZE", ",", "otherwise", "it", "must", "be", "EXPECTED_BITS", "itself", ".", "Return", "true", "if", "the", "argument", "is", "valid", ",", "otherwise", "report", "an", "appropriate", "error", ".", "Note", "that", "we", "do", "n't", "check", "whether", "the", "scalar", "type", "actually", "has", "the", "required", "properties", ",", "since", "that", "'s", "subject", "to", "implicit", "promotions", "and", "conversions", ".", "Instead", "we", "just", "use", "the", "expected", "properties", "to", "tune", "the", "error", "message", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a scalar element\"", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects a scalar integer\"", "1" ]

[]

[ "<s>", "void", "Finish", "(", "MachineBasicBlock", "&", "MBB", ",", "MOVEMState", "&", "State", ")", "{", "auto", "MI", "=", "State", ".", "begin", "(", ")", ";", "auto", "End", "=", "State", ".", "end", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "std", "::", "next", "(", "MI", ")", "==", "End", ")", "{", "State", "=", "MOVEMState", "(", ")", ";", "return", ";", "}", "while", "(", "MI", "!=", "End", ")", "{", "auto", "Next", "=", "std", "::", "next", "(", "MI", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "MI", "=", "Next", ";", "}", "if", "(", "State", ".", "isLoad", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "End", ",", "DL", ",", "TII", "->", "get", "(", "M68k", "::", "MOVM32mp", ")", ")", ".", "addImm", "(", "State", ".", "getMask", "(", ")", ")", ".", "addImm", "(", "State", ".", "getFinalOffset", "(", ")", ")", ".", "addReg", "(", "State", ".", "getBase", "(", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "End", ",", "DL", ",", "TII", "->", "get", "(", "M68k", "::", "MOVM32pm", ")", ")", ".", "addImm", "(", "State", ".", "getFinalOffset", "(", ")", ")", ".", "addReg", "(", "State", ".", "getBase", "(", ")", ")", ".", "addImm", "(", "State", ".", "getMask", "(", ")", ")", ";", "}", "State", "=", "MOVEMState", "(", ")", ";", "}", "</s>" ]

[ "Finish", "-", "Do", "final", "processing", "and", "write", "the", "object", "to", "the", "output", "stream", "." ]

[ "M68k", "M68k::MOVM32mp", "M68k::MOVM32pm" ]

[]

[ "<s>", "void", "ix86_expand_reduc", "(", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "rtx", "dest", ",", "rtx", "in", ")", "{", "rtx", "half", ",", "dst", ",", "vec", "=", "in", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "in", ")", ";", "int", "i", ";", "if", "(", "TARGET_SSE4_1", "&&", "mode", "==", "V8HImode", "&&", "fn", "==", "gen_uminv8hi3", ")", "{", "emit_insn", "(", "gen_sse4_1_phminposuw", "(", "dest", ",", "in", ")", ")", ";", "return", ";", "}", "for", "(", "i", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "i", ">", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", ";", "i", ">>=", "1", ")", "{", "half", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_reduc_half", "(", "half", ",", "vec", ",", "i", ")", ";", "if", "(", "i", "==", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", "*", "2", ")", "dst", "=", "dest", ";", "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "fn", "(", "dst", ",", "half", ",", "vec", ")", ")", ";", "vec", "=", "dst", ";", "}", "}", "</s>" ]

[ "Expand", "a", "vector", "reduction", ".", "FN", "is", "the", "binary", "pattern", "to", "reduce", ";", "DEST", "is", "the", "destination", ";", "IN", "is", "the", "input", "vector", "." ]

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

[]

[ "<s>", "static", "rtx", "ix86_struct_value_rtx", "(", "tree", "type", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "static", "bool", "warnedsse", ",", "warnedmmx", ";", "if", "(", "type", ")", "{", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "!", "TARGET_SSE", "&&", "!", "warnedsse", ")", "{", "if", "(", "mode", "==", "TImode", "||", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", ")", "{", "warnedsse", "=", "true", ";", "warning", "(", "0", ",", "\"SSE vector return without SSE enabled \"", "\"changes the ABI\"", ")", ";", "}", "}", "if", "(", "!", "TARGET_MMX", "&&", "!", "warnedmmx", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "warnedmmx", "=", "true", ";", "warning", "(", "0", ",", "\"MMX vector return without MMX enabled \"", "\"changes the ABI\"", ")", ";", "}", "}", "}", "return", "NULL", ";", "}", "</s>" ]

[ "When", "returning", "SSE", "vector", "types", ",", "we", "have", "a", "choice", "of", "either", "(", "1", ")", "being", "abi", "incompatible", "with", "a", "-march", "switch", ",", "or", "(", "2", ")", "generating", "an", "error", ".", "Given", "no", "good", "solution", ",", "I", "think", "the", "safest", "thing", "is", "one", "warning", ".", "The", "user", "wo", "n't", "be", "able", "to", "use", "-Werror", ",", "but", "....", "Choose", "the", "STRUCT_VALUE_RTX", "hook", "because", "that", "'s", "(", "at", "present", ")", "only", "called", "in", "response", "to", "actually", "generating", "a", "caller", "or", "callee", "that", "uses", "such", "a", "type", ".", "As", "opposed", "to", "RETURN_IN_MEMORY", ",", "which", "is", "called", "via", "aggregate_value_p", "for", "general", "type", "probing", "from", "tree-ssa", "." ]

[ "i386", "16", "0", "\"SSE vector return without SSE enabled \"", "\"changes the ABI\"", "8", "0", "\"MMX vector return without MMX enabled \"", "\"changes the ABI\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R29R28", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlign", "(", ")", "==", "Align", "(", "1", ")", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SUBIWRdK", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ")", ";", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "AVR", "::", "R31R30", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::R29R28", "0", "1", "\"Unsupported stack alignment\"", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::SUBIWRdK", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getGPRsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setParsingInlineAsm", "(", "false", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "getParser", "(", ")", ".", "setParsingInlineAsm", "(", "true", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "\".even\"", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_proc\"", ")", "return", "parseDirectiveFPOProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_setframe\"", ")", "return", "parseDirectiveFPOSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_pushreg\"", ")", "return", "parseDirectiveFPOPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_stackalloc\"", ")", "return", "parseDirectiveFPOStackAlloc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endprologue\"", ")", "return", "parseDirectiveFPOEndPrologue", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endproc\"", ")", "return", "parseDirectiveFPOEndProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".even\"", "\".cv_fpo_proc\"", "\".cv_fpo_setframe\"", "\".cv_fpo_pushreg\"", "\".cv_fpo_stackalloc\"", "\".cv_fpo_endprologue\"", "\".cv_fpo_endproc\"" ]

[]

[ "<s>", "static", "void", "rs6000_elf_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "first", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "!", "TARGET_AIX", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "rtx", "sym_ref", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "size_t", "len", "=", "strlen", "(", "XSTR", "(", "sym_ref", ",", "0", ")", ")", ";", "char", "*", "str", "=", "alloca", "(", "len", "+", "2", ")", ";", "str", "[", "0", "]", "=", "'.'", ";", "memcpy", "(", "str", "+", "1", ",", "XSTR", "(", "sym_ref", ",", "0", ")", ",", "len", "+", "1", ")", ";", "XSTR", "(", "sym_ref", ",", "0", ")", "=", "ggc_alloc_string", "(", "str", ",", "len", "+", "1", ")", ";", "}", "}", "</s>" ]

[ "For", "a", "SYMBOL_REF", ",", "set", "generic", "flags", "and", "then", "perform", "some", "target-specific", "processing", ".", "When", "the", "AIX", "ABI", "is", "requested", "on", "a", "non-AIX", "system", ",", "replace", "the", "function", "name", "with", "the", "real", "name", "(", "with", "a", "leading", ".", ")", "rather", "than", "the", "function", "descriptor", "name", ".", "This", "saves", "a", "lot", "of", "overriding", "code", "to", "read", "the", "prefixes", "." ]

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

[]

[ "<s>", "int", "regs_used", "(", "rtx", "x", ",", "int", "is_dest", ")", "{", "enum", "rtx_code", "code", ";", "const", "char", "*", "fmt", ";", "int", "used", "=", "0", ";", "if", "(", "!", "x", ")", "return", "used", ";", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "x", ")", "<", "16", ")", "return", "(", "(", "(", "1", "<<", "HARD_REGNO_NREGS", "(", "0", ",", "GET_MODE", "(", "x", ")", ")", ")", "-", "1", ")", "<<", "(", "REGNO", "(", "x", ")", "+", "is_dest", ")", ")", ";", "return", "0", ";", "case", "SUBREG", ":", "{", "rtx", "y", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "REG_P", "(", "y", ")", ")", "break", ";", "if", "(", "REGNO", "(", "y", ")", "<", "16", ")", "return", "(", "(", "(", "1", "<<", "HARD_REGNO_NREGS", "(", "0", ",", "GET_MODE", "(", "x", ")", ")", ")", "-", "1", ")", "<<", "(", "REGNO", "(", "y", ")", "+", "subreg_regno_offset", "(", "REGNO", "(", "y", ")", ",", "GET_MODE", "(", "y", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", "+", "is_dest", ")", ")", ";", "return", "0", ";", "}", "case", "SET", ":", "return", "regs_used", "(", "SET_SRC", "(", "x", ")", ",", "0", ")", "|", "regs_used", "(", "SET_DEST", "(", "x", ")", ",", "16", ")", ";", "case", "RETURN", ":", "return", "0x00ffff00", ";", "case", "CLOBBER", ":", "is_dest", "=", "1", ";", "break", ";", "case", "MEM", ":", "is_dest", "=", "0", ";", "break", ";", "case", "CALL", ":", "used", "|=", "0x00ff00f0", ";", "break", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "int", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "int", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "used", "|=", "regs_used", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "is_dest", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "used", "|=", "regs_used", "(", "XEXP", "(", "x", ",", "i", ")", ",", "is_dest", ")", ";", "}", "return", "used", ";", "}", "</s>" ]

[ "Given", "a", "X", ",", "a", "pattern", "of", "an", "insn", "or", "a", "part", "of", "it", ",", "return", "a", "mask", "of", "used", "general", "registers", ".", "Bits", "0", "..", "15", "mean", "that", "the", "respective", "registers", "are", "used", "as", "inputs", "in", "the", "instruction", ".", "Bits", "16", "..", "31", "mean", "that", "the", "registers", "0", "..", "15", ",", "respectively", ",", "are", "used", "as", "outputs", ",", "or", "are", "clobbered", ".", "IS_DEST", "should", "be", "set", "to", "16", "if", "X", "is", "the", "destination", "of", "a", "SET", ",", "else", "to", "0", "." ]

[ "sh", "0", "16", "1", "0", "1", "0", "16", "1", "0", "1", "0", "0", "16", "0x00ffff00", "1", "0", "0x00ff00f0", "1", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "loadImmediate", "(", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "*", "NewImm", ")", "const", "{", "MipsAnalyzeImmediate", "AnalyzeImm", ";", "const", "MipsSubtarget", "&", "STI", "=", "Subtarget", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Size", "=", "STI", ".", "isABI_N64", "(", ")", "?", "64", ":", "32", ";", "unsigned", "LUi", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "LUi64", ":", "Mips", "::", "LUi", ";", "unsigned", "ZEROReg", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "bool", "LastInstrIsADDiu", "=", "NewImm", ";", "const", "MipsAnalyzeImmediate", "::", "InstSeq", "&", "Seq", "=", "AnalyzeImm", ".", "Analyze", "(", "Imm", ",", "Size", ",", "LastInstrIsADDiu", ")", ";", "MipsAnalyzeImmediate", "::", "InstSeq", "::", "const_iterator", "Inst", "=", "Seq", ".", "begin", "(", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "&&", "(", "!", "LastInstrIsADDiu", "||", "(", "Seq", ".", "size", "(", ")", ">", "1", ")", ")", ")", ";", "unsigned", "Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "LUi", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "LUi", ")", ",", "Reg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "ZEROReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", "-", "LastInstrIsADDiu", ";", "++", "Inst", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "if", "(", "LastInstrIsADDiu", ")", "*", "NewImm", "=", "Inst", "->", "ImmOpnd", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "Mips", "Mips", "Mips", "Mips", "64", "32", "Mips::LUi64", "Mips::LUi", "Mips::ZERO_64", "Mips::ZERO", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "Mips", "Mips", "1", "16", "16", "16" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "Subtarget", ".", "hasVector", "(", ")", ")", "VerifyVectorTypes", "(", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "GHC", ")", "report_fatal_error", "(", "\"GHC functions return void only\"", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "Register", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "SystemZISD::RET_FLAG", "MVT::Other", "\"GHC functions return void only\"", "4", "0", "\"Can only return in registers!\"", "1", "0", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "ia64_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "BR_REGS", ")", ")", "return", "from", "==", "to", ";", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "from", ")", "!=", "SCALAR_FLOAT_MODE_P", "(", "to", ")", ")", "return", "!", "reg_classes_intersect_p", "(", "rclass", ",", "FR_REGS", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "In", "BR", "regs", ",", "we", "ca", "n't", "change", "the", "DImode", "at", "all", ".", "In", "FP", "regs", ",", "we", "ca", "n't", "change", "FP", "values", "to", "integer", "values", "and", "vice", "versa", ",", "but", "we", "can", "change", "e.g", ".", "DImode", "to", "SImode", ",", "and", "V2SFmode", "into", "DImode", "." ]

[ "ia64" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "TriCoreDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint16_t", "insn16", ";", "if", "(", "!", "readInstruction16", "(", "Bytes", ",", "Address", ",", "Size", ",", "insn16", ")", ")", "{", "return", "Fail", ";", "}", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "instr", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "uint32_t", "insn32", ";", "if", "(", "!", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "insn32", ")", ")", "{", "return", "Fail", ";", "}", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "instr", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "Fail", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "2", "4" ]

[]

[ "<s>", "MVT", "AlphaTargetLowering", "::", "getSetCCResultType", "(", "MVT", "VT", ")", "const", "{", "return", "MVT", "::", "i64", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "MVT::i64" ]

[]

[ "<s>", "static", "void", "aarch64_emit_atomic_load_op", "(", "enum", "aarch64_atomic_load_op_code", "code", ",", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "mem", ",", "rtx", "model", ")", "{", "typedef", "rtx", "(", "*", "aarch64_atomic_load_op_fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "const", "aarch64_atomic_load_op_fn", "plus", "[", "]", "=", "{", "gen_aarch64_atomic_loadaddqi", ",", "gen_aarch64_atomic_loadaddhi", ",", "gen_aarch64_atomic_loadaddsi", ",", "gen_aarch64_atomic_loadadddi", "}", ";", "const", "aarch64_atomic_load_op_fn", "eor", "[", "]", "=", "{", "gen_aarch64_atomic_loadeorqi", ",", "gen_aarch64_atomic_loadeorhi", ",", "gen_aarch64_atomic_loadeorsi", ",", "gen_aarch64_atomic_loadeordi", "}", ";", "const", "aarch64_atomic_load_op_fn", "ior", "[", "]", "=", "{", "gen_aarch64_atomic_loadsetqi", ",", "gen_aarch64_atomic_loadsethi", ",", "gen_aarch64_atomic_loadsetsi", ",", "gen_aarch64_atomic_loadsetdi", "}", ";", "const", "aarch64_atomic_load_op_fn", "bic", "[", "]", "=", "{", "gen_aarch64_atomic_loadclrqi", ",", "gen_aarch64_atomic_loadclrhi", ",", "gen_aarch64_atomic_loadclrsi", ",", "gen_aarch64_atomic_loadclrdi", "}", ";", "aarch64_atomic_load_op_fn", "gen", ";", "int", "idx", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "idx", "=", "0", ";", "break", ";", "case", "E_HImode", ":", "idx", "=", "1", ";", "break", ";", "case", "E_SImode", ":", "idx", "=", "2", ";", "break", ";", "case", "E_DImode", ":", "idx", "=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "AARCH64_LDOP_PLUS", ":", "gen", "=", "plus", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_XOR", ":", "gen", "=", "eor", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_OR", ":", "gen", "=", "ior", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_BIC", ":", "gen", "=", "bic", "[", "idx", "]", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "mem", ",", "src", ",", "model", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "atomic", "load-operate", "." ]

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

[]

[ "<s>", "static", "void", "emit_cbcond_insn", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "label", ")", "{", "rtx", "if_then_else", ";", "if_then_else", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "if_then_else", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "jump", "insn", "for", "the", "UA2011", "architecture", "using", "comparison", "code", "CODE", "and", "jump", "target", "LABEL", ".", "This", "function", "exists", "to", "take", "advantage", "of", "the", "UA2011", "Compare", "and", "Branch", "insns", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "sh_fix_range", "(", "const", "char", "*", "const_str", ")", "{", "char", "*", "str", "=", "strcpy", "(", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "const_str", ")", "+", "1", ")", ",", "const_str", ")", ";", "while", "(", "1", ")", "{", "char", "*", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "char", "*", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "int", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "int", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "for", "(", "int", "i", "=", "first", ";", "i", "<=", "last", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "1", ";", "if", "(", "!", "comma", ")", "break", ";", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "}", "}", "</s>" ]

[ "Parse", "the", "-mfixed-range=", "option", "string", "." ]

[ "sh", "1", "1", "0", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "1" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "CMPEHexagon4rr", ":", "case", "Hexagon", "::", "CMPEQri", ":", "case", "Hexagon", "::", "CMPEQrr", ":", "case", "Hexagon", "::", "CMPGT64rr", ":", "case", "Hexagon", "::", "CMPGTU64rr", ":", "case", "Hexagon", "::", "CMPGTUri", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTri", ":", "case", "Hexagon", "::", "CMPGTrr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "CMPbEQri_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_ubub_V4", ":", "case", "Hexagon", "::", "CMPbGTUri_V4", ":", "case", "Hexagon", "::", "CMPbGTUrr_V4", ":", "case", "Hexagon", "::", "CMPbGTrr_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "CMPhEQri_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_shl_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_xor_V4", ":", "case", "Hexagon", "::", "CMPhGTUri_V4", ":", "case", "Hexagon", "::", "CMPhGTUrr_V4", ":", "case", "Hexagon", "::", "CMPhGTrr_shl_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "CMPEHexagon4rr", ":", "case", "Hexagon", "::", "CMPEQrr", ":", "case", "Hexagon", "::", "CMPGT64rr", ":", "case", "Hexagon", "::", "CMPGTU64rr", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTrr", ":", "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_ubub_V4", ":", "case", "Hexagon", "::", "CMPbGTUrr_V4", ":", "case", "Hexagon", "::", "CMPbGTrr_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_shl_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_xor_V4", ":", "case", "Hexagon", "::", "CMPhGTUrr_V4", ":", "case", "Hexagon", "::", "CMPhGTrr_shl_V4", ":", "SrcReg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "case", "Hexagon", "::", "CMPEQri", ":", "case", "Hexagon", "::", "CMPGTUri", ":", "case", "Hexagon", "::", "CMPGTri", ":", "case", "Hexagon", "::", "CMPbEQri_V4", ":", "case", "Hexagon", "::", "CMPbGTUri_V4", ":", "case", "Hexagon", "::", "CMPhEQri_V4", ":", "case", "Hexagon", "::", "CMPhGTUri_V4", ":", "SrcReg2", "=", "0", ";", "Value", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "Hexagon", "Hexagon", "Hexagon::CMPEHexagon4rr", "Hexagon::CMPEQri", "Hexagon::CMPEQrr", "Hexagon::CMPGT64rr", "Hexagon::CMPGTU64rr", "Hexagon::CMPGTUri", "Hexagon::CMPGTUrr", "Hexagon::CMPGTri", "Hexagon::CMPGTrr", "1", "0", "Hexagon::CMPbEQri_V4", "Hexagon::CMPbEQrr_sbsb_V4", "Hexagon::CMPbEQrr_ubub_V4", "Hexagon::CMPbGTUri_V4", "Hexagon::CMPbGTUrr_V4", "Hexagon::CMPbGTrr_V4", "1", "0xFF", "Hexagon::CMPhEQri_V4", "Hexagon::CMPhEQrr_shl_V4", "Hexagon::CMPhEQrr_xor_V4", "Hexagon::CMPhGTUri_V4", "Hexagon::CMPhGTUrr_V4", "Hexagon::CMPhGTrr_shl_V4", "1", "0xFFFF", "Hexagon::CMPEHexagon4rr", "Hexagon::CMPEQrr", "Hexagon::CMPGT64rr", "Hexagon::CMPGTU64rr", "Hexagon::CMPGTUrr", "Hexagon::CMPGTrr", "Hexagon::CMPbEQrr_sbsb_V4", "Hexagon::CMPbEQrr_ubub_V4", "Hexagon::CMPbGTUrr_V4", "Hexagon::CMPbGTrr_V4", "Hexagon::CMPhEQrr_shl_V4", "Hexagon::CMPhEQrr_xor_V4", "Hexagon::CMPhGTUrr_V4", "Hexagon::CMPhGTrr_shl_V4", "2", "Hexagon::CMPEQri", "Hexagon::CMPGTUri", "Hexagon::CMPGTri", "Hexagon::CMPbEQri_V4", "Hexagon::CMPbGTUri_V4", "Hexagon::CMPhEQri_V4", "Hexagon::CMPhGTUri_V4", "0", "2" ]

[]

[ "<s>", "static", "void", "free_array_of_ptrs", "(", "void", "*", "*", "ptr", ",", "unsigned", "n", ")", "{", "unsigned", "i", ";", "if", "(", "!", "ptr", ")", "return", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "!", "ptr", "[", "i", "]", ")", "break", ";", "free", "(", "ptr", "[", "i", "]", ")", ";", "}", "free", "(", "ptr", ")", ";", "return", ";", "}", "</s>" ]

[ "Auxiliary", "function", "that", "frees", "elements", "of", "PTR", "and", "PTR", "itself", ".", "N", "is", "number", "of", "elements", "to", "be", "freed", ".", "If", "PTR", "is", "NULL", ",", "nothing", "is", "freed", ".", "If", "an", "element", "is", "NULL", ",", "subsequent", "elements", "are", "not", "freed", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "}", "</s>" ]

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

[ "X86" ]

[]

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

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "register", "rtx", "addr", ")", "{", "register", "rtx", "breg", ";", "rtx", "offset", ";", "int", "again", "=", "0", ";", "retry", ":", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "MEM", ":", "if", "(", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"*\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"@\"", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "again", "=", "1", ";", "goto", "retry", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_MODIFY", ":", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"(%s)+\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "breg", "=", "0", ";", "offset", "=", "0", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "{", "gcc_assert", "(", "breg", "==", "0", ")", ";", "breg", "=", "addr", ";", "addr", "=", "0", ";", "}", "if", "(", "offset", "!=", "0", ")", "{", "gcc_assert", "(", "addr", "==", "0", ")", ";", "addr", "=", "offset", ";", "}", "if", "(", "addr", "!=", "0", ")", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "if", "(", "breg", "!=", "0", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "breg", ")", "==", "REG", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "breg", ")", "]", ")", ";", "}", "break", ";", "default", ":", "if", "(", "!", "again", "&&", "GET_CODE", "(", "addr", ")", "==", "CONST_INT", ")", "{", "if", "(", "!", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"@$\"", ")", ";", "}", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "pdp11", "0", "\"*\"", "\"@\"", "0", "1", "\"(%s)\"", "\"-(%s)\"", "0", "\"(%s)+\"", "0", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "\"(%s)\"", "\"@$\"" ]

[]

[ "<s>", "char", "const", "*", "HexagonMCInstrInfo", "::", "getName", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "return", "MCII", ".", "getName", "(", "MCI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "MCSymbol", "*", "X86MCInstLower", "::", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "assert", "(", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isMBB", "(", ")", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "MCSymbol", "*", "Sym", "=", "nullptr", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "case", "X86II", "::", "MO_DLLIMPORT", ":", "Name", "+=", "\"__imp_\"", ";", "break", ";", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "break", ";", "}", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "AsmPrinter", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "assert", "(", "Suffix", ".", "empty", "(", ")", ")", ";", "Sym", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "}", "Name", "+=", "Suffix", ";", "if", "(", "!", "Sym", ")", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", ")", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "break", ";", "}", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "X86", "X86", "\"Isn't a symbol reference\"", "128", "X86II::MO_DLLIMPORT", "\"__imp_\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"$non_lazy_ptr\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "virtual", "const", "BlackfinRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "Blackfin" ]

[]

[ "<s>", "const", "char", "*", "avr_out_sbxx_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "comp", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "bool", "long_jump", "=", "get_attr_length", "(", "insn", ")", ">=", "4", ";", "bool", "reverse", "=", "long_jump", "||", "jump_over_one_insn_p", "(", "insn", ",", "operands", "[", "3", "]", ")", ";", "if", "(", "comp", "==", "GE", ")", "comp", "=", "EQ", ";", "else", "if", "(", "comp", "==", "LT", ")", "comp", "=", "NE", ";", "if", "(", "reverse", ")", "comp", "=", "reverse_condition", "(", "comp", ")", ";", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CONST_INT", ":", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "if", "(", "low_io_address_operand", "(", "operands", "[", "1", "]", ",", "QImode", ")", ")", "{", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbis %i1,%2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbic %i1,%2\"", ",", "operands", ")", ";", "}", "else", "{", "gcc_assert", "(", "io_address_operand", "(", "operands", "[", "1", "]", ",", "QImode", ")", ")", ";", "output_asm_insn", "(", "\"in __tmp_reg__,%i1\"", ",", "operands", ")", ";", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbrs __tmp_reg__,%2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbrc __tmp_reg__,%2\"", ",", "operands", ")", ";", "}", "break", ";", "case", "REG", ":", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbrs %T1%T2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbrc %T1%T2\"", ",", "operands", ")", ";", "break", ";", "}", "if", "(", "long_jump", ")", "return", "(", "\"rjmp .+4\"", "CR_TAB", "\"jmp %x3\"", ")", ";", "if", "(", "!", "reverse", ")", "return", "\"rjmp %x3\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "branch", "that", "tests", "a", "single", "bit", "of", "a", "register", "(", "QI", ",", "HI", "or", "SImode", ")", "or", "memory", "location", "in", "the", "I/O", "space", "(", "QImode", "only", ")", ".", "Operand", "0", ":", "comparison", "operator", "(", "must", "be", "EQ", "or", "NE", ",", "compare", "bit", "to", "zero", ")", ".", "Operand", "1", ":", "register", "operand", "to", "test", ",", "or", "CONST_INT", "memory", "address", ".", "Operand", "2", ":", "bit", "number", "(", "for", "QImode", "operand", ")", "or", "mask", "(", "HImode", ",", "SImode", ")", ".", "Operand", "3", ":", "label", "to", "jump", "to", "if", "the", "test", "is", "true", "." ]

[ "avr", "0", "4", "3", "1", "1", "\"sbis %i1,%2\"", "\"sbic %i1,%2\"", "1", "\"in __tmp_reg__,%i1\"", "\"sbrs __tmp_reg__,%2\"", "\"sbrc __tmp_reg__,%2\"", "\"sbrs %T1%T2\"", "\"sbrc %T1%T2\"", "\"rjmp .+4\"", "\"jmp %x3\"", "\"rjmp %x3\"", "\"\"" ]

[]

[ "<s>", "void", "ARCFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Process function before frame finalized: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Current stack size: \"", "<<", "MFI", ".", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARC", "::", "GPR32RegClass", ";", "if", "(", "MFI", ".", "hasStackObjects", "(", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created scavenging index RegScavFI=\"", "<<", "RegScavFI", "<<", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Process function before frame finalized: \"", "\"\\n\"", "\"Current stack size: \"", "\"\\n\"", "ARC::GPR32RegClass", "\"Created scavenging index RegScavFI=\"", "\"\\n\"" ]

[]

[ "<s>", "void", "A57ChainingConstraint", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "const", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "LiveIntervals", "&", "LIs", "=", "G", ".", "getMetadata", "(", ")", ".", "LIS", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MF", ")", "{", "Chains", ".", "clear", "(", ")", ";", "for", "(", "const", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "toDel", ";", "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Killing chain \"", "<<", "printReg", "(", "r", ",", "TRI", ")", "<<", "\" at \"", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FMSUBSrrr", ":", "case", "AArch64", "::", "FMADDSrrr", ":", "case", "AArch64", "::", "FNMSUBSrrr", ":", "case", "AArch64", "::", "FNMADDSrrr", ":", "case", "AArch64", "::", "FMSUBDrrr", ":", "case", "AArch64", "::", "FMADDDrrr", ":", "case", "AArch64", "::", "FNMSUBDrrr", ":", "case", "AArch64", "::", "FNMADDDrrr", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ra", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "AArch64", "::", "FMLAv2f32", ":", "case", "AArch64", "::", "FMLSv2f32", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AArch64", "8", "\"Killing chain \"", "\" at \"", "AArch64::FMSUBSrrr", "AArch64::FMADDSrrr", "AArch64::FNMSUBSrrr", "AArch64::FNMADDSrrr", "AArch64::FMSUBDrrr", "AArch64::FMADDDrrr", "AArch64::FNMSUBDrrr", "AArch64::FNMADDDrrr", "0", "3", "AArch64::FMLAv2f32", "AArch64::FMLSv2f32", "0" ]

[]

[ "<s>", "bool", "arc_is_secure_call_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "decl", ")", "return", "false", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"secure_call\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "symbol", "is", "a", "secure", "function", "." ]

[ "arc", "\"secure_call\"" ]

[]

[ "<s>", "rtx", "i860_saveregs", "(", ")", "{", "rtx", "fn", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__builtin_saveregs\"", ")", ";", "rtx", "save", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "valreg", "=", "LIBCALL_VALUE", "(", "Pmode", ")", ";", "rtx", "ret", ";", "emit_move_insn", "(", "save", ",", "valreg", ")", ";", "ret", "=", "emit_library_call_value", "(", "fn", ",", "NULL_RTX", ",", "1", ",", "Pmode", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "ret", ")", "!=", "REG", "||", "REGNO", "(", "ret", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "ret", "=", "copy_to_reg", "(", "ret", ")", ";", "emit_move_insn", "(", "valreg", ",", "save", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Expand", "a", "library", "call", "to", "__builtin_saveregs", "." ]

[ "i860", "\"__builtin_saveregs\"", "1", "0" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "4", "&&", "isMicroMips", "(", "STI", ")", ")", "{", "emitInstruction", "(", "Val", ">>", "16", ",", "2", ",", "STI", ",", "OS", ")", ";", "emitInstruction", "(", "Val", ",", "2", ",", "STI", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "Mips", "Mips", "4", "Mips", "16", "2", "2", "0", "8", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "BTFDebug", "::", "InstLower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", ")", "{", "MDNode", "*", "MDN", "=", "GVar", "->", "getMetadata", "(", "LLVMContext", "::", "MD_preserve_access_index", ")", ";", "DIType", "*", "Ty", "=", "dyn_cast", "<", "DIType", ">", "(", "MDN", ")", ";", "std", "::", "string", "TypeName", "=", "Ty", "->", "getName", "(", ")", ";", "int64_t", "Imm", "=", "AccessOffsets", "[", "TypeName", "+", "\":\"", "+", "GVar", "->", "getName", "(", ")", ".", "str", "(", ")", "]", ";", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GVar", "&&", "!", "GVar", "->", "hasInitializer", "(", ")", "&&", "GVar", "->", "hasExternalLinkage", "(", ")", "&&", "GVar", "->", "getSection", "(", ")", "==", "BPFCoreSharedInfo", "::", "PatchableExtSecName", ")", "{", "const", "IntegerType", "*", "IntTy", "=", "dyn_cast", "<", "IntegerType", ">", "(", "GVar", "->", "getValueType", "(", ")", ")", ";", "assert", "(", "IntTy", ")", ";", "if", "(", "IntTy", "->", "getBitWidth", "(", ")", "==", "64", ")", "OutMI", ".", "setOpcode", "(", "BPF", "::", "LD_imm64", ")", ";", "else", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF::LD_imm64", "1", "BPFCoreSharedInfo::AmaAttr", "\":\"", "BPF::MOV_ri", "0", "BPFCoreSharedInfo::PatchableExtSecName", "64", "BPF::LD_imm64", "BPF::MOV_ri", "0", "0" ]

[]

[ "<s>", "static", "bool", "ix86_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "mode1", "==", "mode2", ")", "return", "true", ";", "if", "(", "ix86_tieable_integer_mode_p", "(", "mode1", ")", "&&", "ix86_tieable_integer_mode_p", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "mode2", "==", "XFmode", ")", "return", "mode1", "==", "SFmode", "||", "mode1", "==", "DFmode", ";", "if", "(", "mode2", "==", "DFmode", ")", "return", "mode1", "==", "SFmode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "64", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "64", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "32", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "32", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "16", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "16", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "8", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "8", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode1", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE1", "is", "accessible", "in", "a", "register", "that", "can", "hold", "MODE2", "without", "copying", ".", "That", "is", ",", "all", "register", "classes", "that", "can", "hold", "MODE2", "can", "also", "hold", "MODE1", "." ]

[ "i386", "64", "64", "32", "32", "16", "16", "8", "8" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedBits", ",", "const", "APInt", "&", "DemandedElts", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "int", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "PINSRB", ":", "case", "X86ISD", "::", "PINSRW", ":", "{", "SDValue", "Vec", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "auto", "*", "CIdx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "MVT", "VecVT", "=", "Vec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "CIdx", "&&", "CIdx", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "VecVT", ".", "getVectorNumElements", "(", ")", ")", "&&", "!", "DemandedElts", "[", "CIdx", "->", "getZExtValue", "(", ")", "]", ")", "return", "Vec", ";", "break", ";", "}", "}", "SmallVector", "<", "int", ",", "16", ">", "ShuffleMask", ";", "SmallVector", "<", "SDValue", ",", "2", ">", "ShuffleOps", ";", "if", "(", "VT", ".", "isSimple", "(", ")", "&&", "VT", ".", "isVector", "(", ")", "&&", "resolveTargetShuffleInputs", "(", "Op", ",", "ShuffleOps", ",", "ShuffleMask", ",", "DAG", ",", "Depth", ")", ")", "{", "int", "NumOps", "=", "ShuffleOps", ".", "size", "(", ")", ";", "if", "(", "ShuffleMask", ".", "size", "(", ")", "==", "(", "unsigned", ")", "NumElts", "&&", "llvm", "::", "all_of", "(", "ShuffleOps", ",", "[", "VT", "]", "(", "SDValue", "V", ")", "{", "return", "VT", ".", "getSizeInBits", "(", ")", "==", "V", ".", "getValueSizeInBits", "(", ")", ";", "}", ")", ")", "{", "APInt", "IdentityOp", "=", "APInt", "::", "getAllOnesValue", "(", "NumOps", ")", ";", "bool", "AllUndef", "=", "true", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "M", "=", "ShuffleMask", "[", "i", "]", ";", "if", "(", "SM_SentinelUndef", "==", "M", "||", "!", "DemandedElts", "[", "i", "]", ")", "continue", ";", "AllUndef", "=", "false", ";", "int", "Op", "=", "M", "/", "NumElts", ";", "int", "Index", "=", "M", "%", "NumElts", ";", "if", "(", "M", "<", "0", "||", "Index", "!=", "i", ")", "{", "IdentityOp", ".", "clearAllBits", "(", ")", ";", "break", ";", "}", "IdentityOp", "&=", "APInt", "::", "getOneBitSet", "(", "NumOps", ",", "Op", ")", ";", "if", "(", "IdentityOp", "==", "0", ")", "break", ";", "}", "if", "(", "AllUndef", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "assert", "(", "(", "IdentityOp", "==", "0", "||", "IdentityOp", ".", "countPopulation", "(", ")", "==", "1", ")", "&&", "\"Multiple identity shuffles detected\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "if", "(", "IdentityOp", "[", "i", "]", ")", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "ShuffleOps", "[", "i", "]", ")", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "Op", ",", "DemandedBits", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "}", "</s>" ]

[ "More", "limited", "version", "of", "SimplifyDemandedBits", "that", "can", "be", "used", "to", "``", "look", "through", "''", "ops", "that", "do", "n't", "contribute", "to", "the", "DemandedBits/DemandedElts", "-", "bitwise", "ops", "etc", "." ]

[ "X86", "X86", "X86ISD::PINSRB", "X86ISD::PINSRW", "0", "2", "16", "2", "0", "0", "0", "0", "1", "\"Multiple identity shuffles detected\"", "0" ]

[]

[ "<s>", "void", "tilegx_final_prescan_insn", "(", "rtx_insn", "*", "insn", ")", "{", "insn_mode", "=", "GET_MODE", "(", "insn", ")", ";", "}", "</s>" ]

[ "Implement", "FINAL_PRESCAN_INSN", ".", "This", "is", "used", "to", "emit", "bundles", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "if", "(", "Pred1", ".", "size", "(", ")", ">", "2", "||", "Pred2", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "ARMCC", "::", "CondCodes", "CC1", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "ARMCC", "::", "CondCodes", "CC2", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "CC1", "==", "CC2", ")", "return", "true", ";", "switch", "(", "CC1", ")", "{", "default", ":", "return", "false", ";", "case", "ARMCC", "::", "AL", ":", "return", "true", ";", "case", "ARMCC", "::", "HS", ":", "return", "CC2", "==", "ARMCC", "::", "HI", ";", "case", "ARMCC", "::", "LS", ":", "return", "CC2", "==", "ARMCC", "::", "LO", "||", "CC2", "==", "ARMCC", "::", "EQ", ";", "case", "ARMCC", "::", "GE", ":", "return", "CC2", "==", "ARMCC", "::", "GT", ";", "case", "ARMCC", "::", "LE", ":", "return", "CC2", "==", "ARMCC", "::", "LT", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "ARM", "ARM", "2", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::AL", "ARMCC::HS", "ARMCC::HI", "ARMCC::LS", "ARMCC::LO", "ARMCC::EQ", "ARMCC::GE", "ARMCC::GT", "ARMCC::LE", "ARMCC::LT" ]

[]

[ "<s>", "void", "rs6000_emit_parity", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "rtx", "tmp", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "TARGET_CMPB", ")", "{", "if", "(", "mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_popcntbsi2", "(", "tmp", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_paritysi2_cmpb", "(", "dst", ",", "tmp", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_popcntbdi2", "(", "tmp", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_paritydi2_cmpb", "(", "dst", ",", "tmp", ")", ")", ";", "}", "return", ";", "}", "if", "(", "mode", "==", "SImode", ")", "{", "if", "(", "rs6000_cost", "->", "mulsi_const", ">=", "COSTS_N_INSNS", "(", "3", ")", ")", "{", "rtx", "tmp1", ",", "tmp2", ",", "tmp3", ",", "tmp4", ";", "tmp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_popcntbsi2", "(", "tmp1", ",", "src", ")", ")", ";", "tmp2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "tmp2", ",", "tmp1", ",", "GEN_INT", "(", "16", ")", ")", ")", ";", "tmp3", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_xorsi3", "(", "tmp3", ",", "tmp1", ",", "tmp2", ")", ")", ";", "tmp4", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "tmp4", ",", "tmp3", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_xorsi3", "(", "tmp", ",", "tmp3", ",", "tmp4", ")", ")", ";", "}", "else", "rs6000_emit_popcount", "(", "tmp", ",", "src", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "dst", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}", "else", "{", "if", "(", "rs6000_cost", "->", "muldi", ">=", "COSTS_N_INSNS", "(", "5", ")", ")", "{", "rtx", "tmp1", ",", "tmp2", ",", "tmp3", ",", "tmp4", ",", "tmp5", ",", "tmp6", ";", "tmp1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_popcntbdi2", "(", "tmp1", ",", "src", ")", ")", ";", "tmp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "tmp2", ",", "tmp1", ",", "GEN_INT", "(", "32", ")", ")", ")", ";", "tmp3", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_xordi3", "(", "tmp3", ",", "tmp1", ",", "tmp2", ")", ")", ";", "tmp4", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "tmp4", ",", "tmp3", ",", "GEN_INT", "(", "16", ")", ")", ")", ";", "tmp5", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_xordi3", "(", "tmp5", ",", "tmp3", ",", "tmp4", ")", ")", ";", "tmp6", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "tmp6", ",", "tmp5", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_xordi3", "(", "tmp", ",", "tmp5", ",", "tmp6", ")", ")", ";", "}", "else", "rs6000_emit_popcount", "(", "tmp", ",", "src", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "dst", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "parity", "intrinsic", "on", "TARGET_POPCNTB", "targets", ".", "DST", "is", "the", "target", ",", "and", "SRC", "is", "the", "argument", "operand", "." ]

[ "powerpcspe", "3", "16", "8", "5", "32", "16", "8" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "isThumb", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "isThumb", ")", ",", "JITInfo", "(", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "DefRelocModel", "=", "getRelocationModel", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "ARM", "architecture", "model", "." ]

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

[]

[ "<s>", "bool", "AMDGPUUnifyMetadata", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "const", "char", "*", "Vers", "[", "]", "=", "{", "kOCLMD", "::", "SpirVer", ",", "kOCLMD", "::", "OCLVer", "}", ";", "const", "char", "*", "Exts", "[", "]", "=", "{", "kOCLMD", "::", "UsedExt", ",", "kOCLMD", "::", "UsedOptCoreFeat", ",", "kOCLMD", "::", "CompilerOptions", ",", "kOCLMD", "::", "LLVMIdent", "}", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "Vers", ")", "Changed", "|=", "unifyVersionMD", "(", "M", ",", "I", ",", "true", ")", ";", "for", "(", "auto", "&", "I", ":", "Exts", ")", "Changed", "|=", "unifyExtensionMD", "(", "M", ",", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos PML Profile Import Pass\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos PML Profile Import Pass\"" ]

[]

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

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

[ "MMIX" ]

[]

[ "<s>", "void", "MipsCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "unsigned", "OriginalIndex", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "SmallVectorImpl", "<", "unsigned", ">", "&", "SplitArgsOrigIndices", ")", "const", "{", "SplitArgs", ".", "push_back", "(", "OrigArg", ")", ";", "SplitArgsOrigIndices", ".", "push_back", "(", "OriginalIndex", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "XtensaInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "const", "char", "*", "output_branchy_insn", "(", "enum", "rtx_code", "code", ",", "const", "char", "*", "templ", ",", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "rtx_insn", "*", "next_insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "next_insn", "&&", "JUMP_P", "(", "next_insn", ")", "&&", "condjump_p", "(", "next_insn", ")", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "next_insn", ")", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "code", ")", "{", "rtx_code_label", "*", "lab", "=", "gen_label_rtx", "(", ")", ";", "emit_label_after", "(", "lab", ",", "next_insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "lab", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "next_insn", ")", ")", "+", "get_attr_length", "(", "next_insn", ")", ")", ";", "operands", "[", "9", "]", "=", "lab", ";", "return", "templ", ";", "}", "else", "{", "int", "offset", "=", "(", "branch_dest", "(", "next_insn", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "next_insn", ")", ")", "+", "4", ")", ";", "if", "(", "offset", ">=", "-", "252", "&&", "offset", "<=", "258", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", ")", "src", "=", "XEXP", "(", "src", ",", "1", ")", ";", "operands", "[", "9", "]", "=", "src", ";", "return", "templ", ";", "}", "}", "}", "rtx_code_label", "*", "lab", "=", "gen_label_rtx", "(", ")", ";", "emit_label_after", "(", "lab", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "lab", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "+", "get_attr_length", "(", "insn", ")", ")", ";", "operands", "[", "9", "]", "=", "lab", ";", "return", "templ", ";", "}", "</s>" ]

[ "Output", "a", "code", "sequence", "for", "INSN", "using", "TEMPL", "with", "OPERANDS", ";", "but", "before", ",", "fill", "in", "operands", "9", "as", "a", "label", "to", "the", "successor", "insn", ".", "We", "try", "to", "use", "jump", "threading", "where", "possible", ".", "IF", "CODE", "matches", "the", "comparison", "in", "the", "IF_THEN_ELSE", "of", "a", "following", "jump", ",", "we", "assume", "the", "jump", "is", "taken", ".", "I.e", ".", "EQ", "means", "follow", "jmp", "and", "bf", ",", "NE", "means", "follow", "jmp", "and", "bt", ",", "if", "the", "address", "is", "in", "range", "." ]

[ "sh", "0", "9", "4", "252", "258", "1", "9", "9" ]

[]

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

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

[ "SPIRV" ]

[]

[ "<s>", "SDValue", "TGSITargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "mf", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "reginfo", "=", "mf", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "ccinfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCAssignFn", "*", "ccfn", "=", "KernCC_TGSI", ";", "ccinfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "ccfn", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "va", "=", "ArgLocs", "[", "i", "]", ";", "MVT", "vt", "=", "va", ".", "getValVT", "(", ")", ";", "SDValue", "arg", ";", "if", "(", "va", ".", "isRegLoc", "(", ")", ")", "{", "unsigned", "vreg", "=", "reginfo", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "vt", ")", ")", ";", "reginfo", ".", "addLiveIn", "(", "va", ".", "getLocReg", "(", ")", ",", "vreg", ")", ";", "arg", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "vreg", ",", "vt", ")", ";", "}", "else", "{", "SDValue", "ptr", "=", "DAG", ".", "getConstant", "(", "va", ".", "getLocMemOffset", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "arg", "=", "DAG", ".", "getNode", "(", "TGSIISD", "::", "LOAD_INPUT", ",", "dl", ",", "vt", ",", "Chain", ",", "ptr", ")", ";", "}", "InVals", ".", "push_back", "(", "arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "ISD::InputArg", "16", "TGSI", "0", "MVT::i32", "TGSIISD::LOAD_INPUT" ]

[]

[ "<s>", "unsigned", "int", "AArch64InstrInfo", "::", "getTailDuplicateSize", "(", "CodeGenOpt", "::", "Level", "OptLevel", ")", "const", "{", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Aggressive", "?", "6", ":", "2", ";", "}", "</s>" ]

[ "Returns", "the", "target-specific", "default", "value", "for", "tail", "duplication", "." ]

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

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "assert", "(", "Pred1", ".", "size", "(", ")", "==", "2", "&&", "Pred2", ".", "size", "(", ")", "==", "2", ")", ";", "unsigned", "preg1", "=", "Pred1", "[", "0", "]", ".", "getReg", "(", ")", ";", "int", "flag1", "=", "Pred1", "[", "1", "]", ".", "getImm", "(", ")", ";", "if", "(", "(", "preg1", "==", "Patmos", "::", "NoRegister", "||", "preg1", "==", "Patmos", "::", "P0", ")", "&&", "!", "flag1", ")", "return", "true", ";", "if", "(", "preg1", "==", "Pred2", "[", "0", "]", ".", "getReg", "(", ")", "&&", "flag1", "==", "Pred2", "[", "1", "]", ".", "getImm", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "Patmos", "Patmos", "2", "2", "0", "1", "Patmos::NoRegister", "Patmos::P0", "0", "1" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "MipsDisassemblerBase", "*", "Dis", "=", "static_cast", "<", "const", "MipsDisassemblerBase", "*", ">", "(", "D", ")", ";", "const", "MCRegisterInfo", "*", "RegInfo", "=", "Dis", "->", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "*", "(", "RegInfo", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCPhysReg", "*", "Z80oldRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "switch", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "CSR_Z80old_C_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "case", "CallingConv", "::", "Z80_LibCall", ":", "case", "CallingConv", "::", "Z80_LibCall_AC", ":", "case", "CallingConv", "::", "Z80_LibCall_BC", ":", "case", "CallingConv", "::", "Z80_LibCall_C", ":", "case", "CallingConv", "::", "Z80_LibCall_L", ":", "return", "CSR_Z80old_AllRegs_SaveList", ";", "}", "}", "</s>" ]

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

[ "Z80old", "Z80old", "\"Unsupported calling convention\"", "Z80old", "Z80old" ]

[]

[ "<s>", "const", "uint32_t", "*", "LoongArchRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LoongArchSubtarget", ">", "(", ")", ";", "switch", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unrecognized ABI\"", ")", ";", "case", "LoongArchABI", "::", "ABI_ILP32S", ":", "case", "LoongArchABI", "::", "ABI_LP64S", ":", "return", "CSR_ILP32S_LP64S_RegMask", ";", "case", "LoongArchABI", "::", "ABI_ILP32F", ":", "case", "LoongArchABI", "::", "ABI_LP64F", ":", "return", "CSR_ILP32F_LP64F_RegMask", ";", "case", "LoongArchABI", "::", "ABI_ILP32D", ":", "case", "LoongArchABI", "::", "ABI_LP64D", ":", "return", "CSR_ILP32D_LP64D_RegMask", ";", "}", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "LoongArch", "\"Unrecognized ABI\"", "LoongArchABI::ABI_ILP32S", "LoongArchABI::ABI_LP64S", "LoongArchABI::ABI_ILP32F", "LoongArchABI::ABI_LP64F", "LoongArchABI::ABI_ILP32D", "LoongArchABI::ABI_LP64D" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

[ "canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PatmosSPClone", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Clone functions reachable from single-path roots\\n\"", ")", ";", "SmallSet", "<", "StringRef", ",", "32", ">", "used", ";", "loadFromGlobalVariable", "(", "used", ",", "M", ".", "getGlobalVariable", "(", "\"llvm.used\"", ")", ")", ";", "SmallSet", "<", "StringRef", ",", "16", ">", "blacklst", ";", "blacklst", ".", "insert", "(", "Blacklist", ",", "Blacklist", "+", "(", "sizeof", "Blacklist", "/", "sizeof", "Blacklist", "[", "0", "]", ")", ")", ";", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Function", "*", "F", "=", "&", "*", "I", ";", "if", "(", "F", "->", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "F", "->", "hasFnAttribute", "(", "\"sp-root\"", ")", ")", "{", "handleRoot", "(", "F", ")", ";", "(", "void", ")", "SPRoots", ".", "erase", "(", "F", "->", "getName", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "SPRoots", ".", "count", "(", "F", "->", "getName", "(", ")", ")", ")", "{", "F", "->", "addFnAttr", "(", "\"sp-root\"", ")", ";", "handleRoot", "(", "F", ")", ";", "(", "void", ")", "SPRoots", ".", "erase", "(", "F", "->", "getName", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "used", ".", "count", "(", "F", "->", "getName", "(", ")", ")", "&&", "!", "blacklst", ".", "count", "(", "F", "->", "getName", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Used: \"", "<<", "F", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "explore", "(", "cloneAndMark", "(", "F", ",", "true", ")", ",", "true", ")", ";", "continue", ";", "}", "}", "return", "(", "NumSPRoots", "+", "NumSPReachable", "+", "NumSPUsed", ")", ">", "0", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"[Single-Path] Clone functions reachable from single-path roots\\n\"", "32", "\"llvm.used\"", "16", "0", "\"sp-root\"", "\"sp-root\"", "\"Used: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"MSP430 Branch Selector\"", ";", "}", "</s>" ]

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

[ "MSP430", "\"MSP430 Branch Selector\"" ]

[]

[ "<s>", "bool", "AMDGPUSimplifyLibCalls", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "auto", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDIC: process function \"", ";", "F", ".", "printAsOperand", "(", "dbgs", "(", ")", ",", "false", ",", "F", ".", "getParent", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", ")", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "Callee", "==", "0", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AMDIC: try folding \"", "<<", "*", "CI", "<<", "\"\\n\"", ";", "dbgs", "(", ")", ".", "flush", "(", ")", ")", ";", "if", "(", "Simplifier", ".", "fold", "(", "CI", ",", "AA", ")", ")", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AMDGPU", "AMDGPU", "\"AMDIC: process function \"", "0", "\"AMDIC: try folding \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "SparcFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "WDC65816" ]

[]

[ "<s>", "static", "rtx", "expand_mla_mls_lane", "(", "function_expander", "&", "e", ",", "int", "unspec", ")", "{", "e", ".", "rotate_inputs_left", "(", "0", ",", "4", ")", ";", "insn_code", "icode", "=", "code_for_aarch64_lane", "(", "unspec", ",", "e", ".", "vector_mode", "(", "0", ")", ")", ";", "return", "e", ".", "use_exact_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "svmla_lane", "or", "svmls_lane", "using", "floating-point", "unspec", "UNSPEC", "." ]

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

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "loadStackInputValue", "(", "SelectionDAG", "&", "DAG", ",", "EVT", "VT", ",", "const", "SDLoc", "&", "SL", ",", "int64_t", "Offset", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "getOrCreateFixedStackObject", "(", "MFI", ",", "VT", ".", "getStoreSize", "(", ")", ",", "Offset", ")", ";", "auto", "SrcPtrInfo", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getLoad", "(", "VT", ",", "SL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Ptr", ",", "SrcPtrInfo", ",", "Align", "(", "4", ")", ",", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "}", "</s>" ]

[ "Similar", "to", "CreateLiveInRegister", ",", "except", "value", "maybe", "loaded", "from", "a", "stack", "slot", "rather", "than", "passed", "in", "a", "register", "." ]

[ "AMDGPU", "AMDGPU", "MVT::i32", "4" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createMipsOptimizePICCallPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "rs6000_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "from_class", ",", "reg_class_t", "to_class", ")", "{", "enum", "rs6000_reg_type", "from_type", ",", "to_type", ";", "bool", "altivec_p", "=", "(", "(", "from_class", "==", "ALTIVEC_REGS", ")", "||", "(", "to_class", "==", "ALTIVEC_REGS", ")", ")", ";", "from_type", "=", "reg_class_to_reg_type", "[", "(", "int", ")", "from_class", "]", ";", "to_type", "=", "reg_class_to_reg_type", "[", "(", "int", ")", "to_class", "]", ";", "if", "(", "rs6000_secondary_reload_move", "(", "to_type", ",", "from_type", ",", "mode", ",", "(", "secondary_reload_info", "*", ")", "0", ",", "altivec_p", ")", ")", "return", "false", ";", "if", "(", "IS_FP_VECT_REG_TYPE", "(", "from_type", ")", "||", "IS_FP_VECT_REG_TYPE", "(", "to_type", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "FP", "or", "AltiVec", "registers", "and", "anything", "else", ",", "we", "need", "a", "memory", "location", ".", "The", "exception", "is", "when", "we", "are", "targeting", "ppc64", "and", "the", "move", "to/from", "fpr", "to", "gpr", "instructions", "are", "available", ".", "Also", ",", "under", "VSX", ",", "you", "can", "copy", "vector", "registers", "from", "the", "FP", "register", "set", "to", "the", "Altivec", "register", "set", "and", "vice", "versa", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "unsigned", "ARMTTIImpl", "::", "getFPOpCost", "(", "Type", "*", "Ty", ")", "{", "if", "(", "ST", "->", "hasVFP2", "(", ")", "&&", "!", "ST", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", ")", "{", "return", "TargetTransformInfo", "::", "TCC_Basic", ";", "}", "if", "(", "Ty", "->", "isDoubleTy", "(", ")", ")", "{", "return", "ST", "->", "isFPOnlySP", "(", ")", "?", "TargetTransformInfo", "::", "TCC_Expensive", ":", "TargetTransformInfo", "::", "TCC_Basic", ";", "}", "}", "return", "TargetTransformInfo", "::", "TCC_Expensive", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "supporting", "the", "floating", "point", "operation", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "VE", "\"fixupNeedsRelaxation() unimplemented\"" ]

[]

[ "<s>", "bool", "M68kAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isBranch", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "const", "MachineOperand", "*", "&", "Target", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "RISCV", "::", "J", ":", "case", "RISCV", "::", "J64", ":", "case", "RISCV", "::", "JAL", ":", "case", "RISCV", "::", "JAL64", ":", "case", "RISCV", "::", "JALR", ":", "case", "RISCV", "::", "JALR64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_ANY", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BEQ", ":", "case", "RISCV", "::", "BEQ64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_EQ", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BNE", ":", "case", "RISCV", "::", "BNE64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_NE", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BLT", ":", "case", "RISCV", "::", "BLT64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_LT", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BLTU", ":", "case", "RISCV", "::", "BLTU64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_LT", "|", "RISCV", "::", "CCMASK_CMP_UO", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BGE", ":", "case", "RISCV", "::", "BGE64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_GE", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BGEU", ":", "case", "RISCV", "::", "BGEU64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_GE", "|", "RISCV", "::", "CCMASK_CMP_UO", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BGT", ":", "case", "RISCV", "::", "BGT64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_GT", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BGTU", ":", "case", "RISCV", "::", "BGTU64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_GT", "|", "RISCV", "::", "CCMASK_CMP_UO", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BLE", ":", "case", "RISCV", "::", "BLE64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_LE", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "case", "RISCV", "::", "BLEU", ":", "case", "RISCV", "::", "BLEU64", ":", "Cond", "[", "0", "]", ".", "setImm", "(", "RISCV", "::", "CCMASK_CMP_LE", "|", "RISCV", "::", "CCMASK_CMP_UO", ")", ";", "Target", "=", "&", "MI", "->", "getOperand", "(", "0", ")", ";", "return", "true", ";", "default", ":", "assert", "(", "!", "MI", "->", "getDesc", "(", ")", ".", "isBranch", "(", ")", "&&", "\"Unknown branch opcode\"", ")", ";", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "this", "is", "a", "conditional", ",", "unconditional", ",", "or", "indirect", "branch", "." ]

[ "RISCV", "RISCV", "RISCV::J", "RISCV::J64", "RISCV::JAL", "RISCV::JAL64", "RISCV::JALR", "RISCV::JALR64", "0", "RISCV::CCMASK_ANY", "0", "RISCV::BEQ", "RISCV::BEQ64", "0", "RISCV::CCMASK_CMP_EQ", "0", "RISCV::BNE", "RISCV::BNE64", "0", "RISCV::CCMASK_CMP_NE", "0", "RISCV::BLT", "RISCV::BLT64", "0", "RISCV::CCMASK_CMP_LT", "0", "RISCV::BLTU", "RISCV::BLTU64", "0", "RISCV::CCMASK_CMP_LT", "RISCV::CCMASK_CMP_UO", "0", "RISCV::BGE", "RISCV::BGE64", "0", "RISCV::CCMASK_CMP_GE", "0", "RISCV::BGEU", "RISCV::BGEU64", "0", "RISCV::CCMASK_CMP_GE", "RISCV::CCMASK_CMP_UO", "0", "RISCV::BGT", "RISCV::BGT64", "0", "RISCV::CCMASK_CMP_GT", "0", "RISCV::BGTU", "RISCV::BGTU64", "0", "RISCV::CCMASK_CMP_GT", "RISCV::CCMASK_CMP_UO", "0", "RISCV::BLE", "RISCV::BLE64", "0", "RISCV::CCMASK_CMP_LE", "0", "RISCV::BLEU", "RISCV::BLEU64", "0", "RISCV::CCMASK_CMP_LE", "RISCV::CCMASK_CMP_UO", "0", "\"Unknown branch opcode\"" ]

[]

[ "<s>", "void", "tool_cleanup", "(", "bool", ")", "{", "}", "</s>" ]

[ "Delete", "tempfiles", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "X86AsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MII", ".", "get", "(", "Opc", ")", ";", "if", "(", "ForcedVEXEncoding", "==", "VEXEncoding_EVEX", "&&", "(", "MCID", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "!=", "X86II", "::", "EVEX", ")", "return", "Match_Unsupported", ";", "if", "(", "(", "ForcedVEXEncoding", "==", "VEXEncoding_VEX", "||", "ForcedVEXEncoding", "==", "VEXEncoding_VEX2", "||", "ForcedVEXEncoding", "==", "VEXEncoding_VEX3", ")", "&&", "(", "MCID", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "!=", "X86II", "::", "VEX", ")", "return", "Match_Unsupported", ";", "if", "(", "MCID", ".", "TSFlags", "&", "X86II", "::", "ExplicitVEXPrefix", "&&", "(", "ForcedVEXEncoding", "!=", "VEXEncoding_VEX", "&&", "ForcedVEXEncoding", "!=", "VEXEncoding_VEX2", "&&", "ForcedVEXEncoding", "!=", "VEXEncoding_VEX3", ")", ")", "return", "Match_Unsupported", ";", "return", "Match_Success", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86II::EncodingMask", "X86II::EVEX", "X86II::EncodingMask", "X86II::VEX", "X86II::ExplicitVEXPrefix" ]

[]

[ "<s>", "bool", "mips_expand_unaligned_store", "(", "rtx", "dest", ",", "rtx", "src", ",", "unsigned", "int", "width", ",", "int", "bitpos", ")", "{", "rtx", "left", ",", "right", ";", "if", "(", "!", "mips_get_unaligned_mem", "(", "&", "dest", ",", "width", ",", "bitpos", ",", "&", "left", ",", "&", "right", ")", ")", "return", "false", ";", "src", "=", "gen_lowpart", "(", "mode_for_size", "(", "width", ",", "MODE_INT", ",", "0", ")", ",", "src", ")", ";", "if", "(", "GET_MODE", "(", "src", ")", "==", "DImode", ")", "{", "emit_insn", "(", "gen_mov_sdl", "(", "dest", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_sdr", "(", "copy_rtx", "(", "dest", ")", ",", "copy_rtx", "(", "src", ")", ",", "right", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_mov_swl", "(", "dest", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_swr", "(", "copy_rtx", "(", "dest", ")", ",", "copy_rtx", "(", "src", ")", ",", "right", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "expand", "(", "set", "(", "zero_extract", "DEST", "WIDTH", "BITPOS", ")", "SRC", ")", ".", "Return", "true", "on", "success", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "arm_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "type", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ";", "}", "</s>" ]

[ "Variable", "sized", "types", "are", "passed", "by", "reference", ".", "This", "is", "a", "GCC", "extension", "to", "the", "ARM", "ABI", "." ]

[ "arm" ]

[]

[ "<s>", "const", "Metadata", "*", "get", "(", "ArrayRef", "<", "const", "Metadata", "*", ">", "MDs", ")", "const", "{", "assert", "(", "ID", "&&", "\"Expected non-zero ID\"", ")", ";", "assert", "(", "ID", "<=", "MDs", ".", "size", "(", ")", "&&", "\"Expected valid ID\"", ")", ";", "return", "MDs", "[", "ID", "-", "1", "]", ";", "}", "</s>" ]

[ "Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "." ]

[ "DirectX", "\"Expected non-zero ID\"", "\"Expected valid ID\"", "1" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "const", "char", "*", "riscv_output_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "enum", "rtx_code", "dest_code", ",", "src_code", ";", "machine_mode", "mode", ";", "bool", "dbl_p", ";", "dest_code", "=", "GET_CODE", "(", "dest", ")", ";", "src_code", "=", "GET_CODE", "(", "src", ")", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "dbl_p", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "if", "(", "dbl_p", "&&", "riscv_split_64bit_move_p", "(", "dest", ",", "src", ")", ")", "return", "\"#\"", ";", "if", "(", "dest_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.x.d\\t%0,%1\"", ":", "\"fmv.x.s\\t%0,%1\"", ";", "if", "(", "src_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"lbu\\t%0,%1\"", ";", "case", "2", ":", "return", "\"lhu\\t%0,%1\"", ";", "case", "4", ":", "return", "\"lw\\t%0,%1\"", ";", "case", "8", ":", "return", "\"ld\\t%0,%1\"", ";", "}", "if", "(", "src_code", "==", "CONST_INT", ")", "return", "\"li\\t%0,%1\"", ";", "if", "(", "src_code", "==", "HIGH", ")", "return", "\"lui\\t%0,%h1\"", ";", "if", "(", "symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "switch", "(", "riscv_classify_symbolic_expression", "(", "src", ")", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "return", "\"la\\t%0,%1\"", ";", "case", "SYMBOL_ABSOLUTE", ":", "return", "\"lla\\t%0,%1\"", ";", "case", "SYMBOL_PCREL", ":", "return", "\"lla\\t%0,%1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "(", "src_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "||", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", ")", "{", "if", "(", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "\"mv\\t%0,%z1\"", ";", "if", "(", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "!", "dbl_p", ")", "return", "\"fmv.s.x\\t%0,%z1\"", ";", "if", "(", "TARGET_64BIT", ")", "return", "\"fmv.d.x\\t%0,%z1\"", ";", "gcc_assert", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "return", "\"fcvt.d.w\\t%0,x0\"", ";", "}", "}", "if", "(", "dest_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"sb\\t%z1,%0\"", ";", "case", "2", ":", "return", "\"sh\\t%z1,%0\"", ";", "case", "4", ":", "return", "\"sw\\t%z1,%0\"", ";", "case", "8", ":", "return", "\"sd\\t%z1,%0\"", ";", "}", "}", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.d\\t%0,%1\"", ":", "\"fmv.s\\t%0,%1\"", ";", "if", "(", "dest_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fsd\\t%1,%0\"", ":", "\"fsw\\t%1,%0\"", ";", "}", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fld\\t%0,%1\"", ":", "\"flw\\t%0,%1\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "instructions", "to", "move", "SRC", "into", "DEST", ".", "Assume", "that", "SRC", "is", "operand", "1", "and", "DEST", "is", "operand", "0", "." ]

[ "riscv", "8", "\"#\"", "\"fmv.x.d\\t%0,%1\"", "\"fmv.x.s\\t%0,%1\"", "1", "\"lbu\\t%0,%1\"", "2", "\"lhu\\t%0,%1\"", "4", "\"lw\\t%0,%1\"", "8", "\"ld\\t%0,%1\"", "\"li\\t%0,%1\"", "\"lui\\t%0,%h1\"", "\"la\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"mv\\t%0,%z1\"", "\"fmv.s.x\\t%0,%z1\"", "\"fmv.d.x\\t%0,%z1\"", "\"fcvt.d.w\\t%0,x0\"", "1", "\"sb\\t%z1,%0\"", "2", "\"sh\\t%z1,%0\"", "4", "\"sw\\t%z1,%0\"", "8", "\"sd\\t%z1,%0\"", "\"fmv.d\\t%0,%1\"", "\"fmv.s\\t%0,%1\"", "\"fsd\\t%1,%0\"", "\"fsw\\t%1,%0\"", "\"fld\\t%0,%1\"", "\"flw\\t%0,%1\"" ]

[]

[ "<s>", "void", "order_regs_for_local_alloc", "(", "void", ")", "{", "if", "(", "!", "leaf_function_p", "(", ")", ")", "{", "static", "const", "int", "reg_nonleaf_alloc_order", "[", "FIRST_PSEUDO_REGISTER", "]", "=", "REG_ALLOC_ORDER", ";", "static", "const", "int", "reg_nonleaf_alloc_order_call0", "[", "FIRST_PSEUDO_REGISTER", "]", "=", "{", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "12", ",", "13", ",", "14", ",", "15", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "26", ",", "27", ",", "28", ",", "29", ",", "30", ",", "31", ",", "32", ",", "33", ",", "34", ",", "0", ",", "1", ",", "16", ",", "17", ",", "35", ",", "}", ";", "memcpy", "(", "reg_alloc_order", ",", "TARGET_WINDOWED_ABI", "?", "reg_nonleaf_alloc_order", ":", "reg_nonleaf_alloc_order_call0", ",", "FIRST_PSEUDO_REGISTER", "*", "sizeof", "(", "int", ")", ")", ";", "}", "else", "{", "int", "i", ",", "num_arg_regs", ";", "int", "nxt", "=", "0", ";", "num_arg_regs", "=", "crtl", "->", "args", ".", "info", ".", "arg_words", ";", "if", "(", "num_arg_regs", ">", "MAX_ARGS_IN_REGISTERS", ")", "num_arg_regs", "=", "MAX_ARGS_IN_REGISTERS", ";", "for", "(", "i", "=", "GP_ARG_FIRST", ";", "i", "<", "16", "-", "num_arg_regs", ";", "i", "++", ")", "reg_alloc_order", "[", "nxt", "++", "]", "=", "i", "+", "num_arg_regs", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_arg_regs", ";", "i", "++", ")", "reg_alloc_order", "[", "nxt", "++", "]", "=", "GP_ARG_FIRST", "+", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "BR_REG_NUM", ";", "i", "++", ")", "reg_alloc_order", "[", "nxt", "++", "]", "=", "BR_REG_FIRST", "+", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "reg_alloc_order", "[", "nxt", "++", "]", "=", "FP_REG_FIRST", "+", "i", ";", "reg_alloc_order", "[", "nxt", "++", "]", "=", "0", ";", "reg_alloc_order", "[", "nxt", "++", "]", "=", "1", ";", "reg_alloc_order", "[", "nxt", "++", "]", "=", "16", ";", "reg_alloc_order", "[", "nxt", "++", "]", "=", "17", ";", "reg_alloc_order", "[", "nxt", "++", "]", "=", "ACC_REG_FIRST", ";", "}", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "xtensa", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "12", "13", "14", "15", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "0", "1", "16", "17", "35", "0", "16", "0", "0", "0", "16", "0", "1", "16", "17" ]

[]

[ "<s>", "static", "int", "getRegClass", "(", "RegisterKind", "Is", ",", "unsigned", "RegWidth", ")", "{", "if", "(", "Is", "==", "IS_VGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "5", ":", "return", "AMDGPU", "::", "VReg_160RegClassID", ";", "case", "6", ":", "return", "AMDGPU", "::", "VReg_192RegClassID", ";", "case", "7", ":", "return", "AMDGPU", "::", "VReg_224RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "case", "32", ":", "return", "AMDGPU", "::", "VReg_1024RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_TTMP", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "TTMP_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "TTMP_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "TTMP_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "TTMP_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "TTMP_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_SGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "SGPR_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "SGPR_128RegClassID", ";", "case", "5", ":", "return", "AMDGPU", "::", "SGPR_160RegClassID", ";", "case", "6", ":", "return", "AMDGPU", "::", "SGPR_192RegClassID", ";", "case", "7", ":", "return", "AMDGPU", "::", "SGPR_224RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "SGPR_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "SGPR_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_AGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "AGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "AReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "AReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "AReg_128RegClassID", ";", "case", "5", ":", "return", "AMDGPU", "::", "AReg_160RegClassID", ";", "case", "6", ":", "return", "AMDGPU", "::", "AReg_192RegClassID", ";", "case", "7", ":", "return", "AMDGPU", "::", "AReg_224RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "AReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "AReg_512RegClassID", ";", "case", "32", ":", "return", "AMDGPU", "::", "AReg_1024RegClassID", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

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

[ "AMDGPU", "1", "1", "AMDGPU::VGPR_32RegClassID", "2", "AMDGPU::VReg_64RegClassID", "3", "AMDGPU::VReg_96RegClassID", "4", "AMDGPU::VReg_128RegClassID", "5", "AMDGPU::VReg_160RegClassID", "6", "AMDGPU::VReg_192RegClassID", "7", "AMDGPU::VReg_224RegClassID", "8", "AMDGPU::VReg_256RegClassID", "16", "AMDGPU::VReg_512RegClassID", "32", "AMDGPU::VReg_1024RegClassID", "1", "1", "AMDGPU::TTMP_32RegClassID", "2", "AMDGPU::TTMP_64RegClassID", "4", "AMDGPU::TTMP_128RegClassID", "8", "AMDGPU::TTMP_256RegClassID", "16", "AMDGPU::TTMP_512RegClassID", "1", "1", "AMDGPU::SGPR_32RegClassID", "2", "AMDGPU::SGPR_64RegClassID", "3", "AMDGPU::SGPR_96RegClassID", "4", "AMDGPU::SGPR_128RegClassID", "5", "AMDGPU::SGPR_160RegClassID", "6", "AMDGPU::SGPR_192RegClassID", "7", "AMDGPU::SGPR_224RegClassID", "8", "AMDGPU::SGPR_256RegClassID", "16", "AMDGPU::SGPR_512RegClassID", "1", "1", "AMDGPU::AGPR_32RegClassID", "2", "AMDGPU::AReg_64RegClassID", "3", "AMDGPU::AReg_96RegClassID", "4", "AMDGPU::AReg_128RegClassID", "5", "AMDGPU::AReg_160RegClassID", "6", "AMDGPU::AReg_192RegClassID", "7", "AMDGPU::AReg_224RegClassID", "8", "AMDGPU::AReg_256RegClassID", "16", "AMDGPU::AReg_512RegClassID", "32", "AMDGPU::AReg_1024RegClassID", "1" ]

[]

[ "<s>", "void", "sparc_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "const", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "const", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "const", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "i", ",", "n_var", "=", "0", ";", "bool", "all_same", "=", "true", ";", "rtx", "mem", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "(", "CONST_SCALAR_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", "||", "CONST_FIXED_P", "(", "x", ")", ")", ")", "n_var", "++", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "4", ")", "{", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "target", ")", ",", "gen_lowpart", "(", "SImode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "8", ")", "{", "emit_move_insn", "(", "gen_lowpart", "(", "DImode", ",", "target", ")", ",", "gen_lowpart", "(", "DImode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "GET_MODE_SIZE", "(", "inner_mode", ")", "==", "GET_MODE_SIZE", "(", "word_mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "2", "*", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "emit_move_insn", "(", "gen_highpart", "(", "word_mode", ",", "target", ")", ",", "gen_lowpart", "(", "word_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "word_mode", ",", "target", ")", ",", "gen_lowpart", "(", "word_mode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ")", ";", "return", ";", "}", "if", "(", "all_same", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "if", "(", "TARGET_VIS2", ")", "{", "vector_init_bshuffle", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "mode", ",", "inner_mode", ")", ";", "return", ";", "}", "if", "(", "mode", "==", "V8QImode", ")", "{", "vector_init_fpmerge", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "mode", "==", "V4HImode", ")", "{", "vector_init_faligndata", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "initialize", "TARGET", "to", "values", "for", "individual", "fields", "VALS", "." ]

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

[]

[ "<s>", "unsigned", "int", "pure_scalable_type_info", "::", "num_zr", "(", ")", "const", "{", "unsigned", "int", "res", "=", "0", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "pieces", ".", "length", "(", ")", ";", "++", "i", ")", "res", "+=", "pieces", "[", "i", "]", ".", "num_zr", ";", "return", "res", ";", "}", "</s>" ]

[ "Return", "the", "total", "number", "of", "vector", "registers", "required", "by", "the", "PST", "." ]

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

[]

[ "<s>", "MCSymbol", "*", "LanaiMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseOffs", "<", "0", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "!=", "0", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StringRef", "getName", "(", ")", "const", "{", "return", "SectionName", ";", "}", "</s>" ]

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

[ "GBZ80" ]

[]

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

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

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

[]

[ "<s>", "FastISel", "*", "WebAssemblyTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "FuncInfo", ",", "const", "TargetLibraryInfo", "*", "LibInfo", ")", "const", "{", "return", "WebAssembly", "::", "createFastISel", "(", "FuncInfo", ",", "LibInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::createFastISel" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_contiguous_prefetch_insn", "(", "insn_code", "icode", ")", "{", "add_input_operand", "(", "icode", ",", "args", "[", "0", "]", ")", ";", "add_address_operand", "(", "get_contiguous_base", "(", "VNx16QImode", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "args", ".", "length", "(", ")", "-", "3", ";", "i", "<", "args", ".", "length", "(", ")", ";", "++", "i", ")", "add_input_operand", "(", "icode", ",", "args", "[", "i", "]", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "which", "prefetches", "from", "address", "operand", "1", "under", "the", "control", "of", "predicate", "operand", "0", ".", "Operands", "2", ",", "3", "and", "4", "respectively", "specify", "the", "svprfop", "value", ",", "the", "PREFETCH", "rw", "flag", "and", "the", "PREFETCH", "locality", "." ]

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

[]

[ "<s>", "static", "int", "frv_string_begins_with", "(", "const", "char", "*", "name", ",", "const", "char", "*", "prefix", ")", "{", "const", "int", "prefix_len", "=", "strlen", "(", "prefix", ")", ";", "return", "(", "strncmp", "(", "name", ",", "prefix", ",", "prefix_len", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "NAME", "(", "a", "STRING_CST", "node", ")", "begins", "with", "PREFIX", "." ]

[ "frv", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "from", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "?", "!", "TARGET_MINIMAL_TOC", "||", "TARGET_NO_TOC", "||", "constant_pool_empty_p", "(", ")", ":", "true", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "For", "the", "RS/6000", ",", "if", "frame", "pointer", "elimination", "is", "being", "done", ",", "we", "would", "like", "to", "convert", "ap", "into", "fp", ",", "not", "sp", ".", "We", "need", "r30", "if", "-mminimal-toc", "was", "specified", ",", "and", "there", "are", "constant", "pool", "references", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "int", "arm_dbx_register_number", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "<", "16", ")", "return", "regno", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ")", "return", "64", "+", "regno", "-", "FIRST_VFP_REGNUM", ";", "else", "return", "256", "+", "(", "regno", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ";", "}", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "104", "+", "regno", "-", "FIRST_IWMMXT_GR_REGNUM", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "112", "+", "regno", "-", "FIRST_IWMMXT_REGNUM", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "arm", "16", "64", "256", "2", "104", "112" ]

[]