Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "MachineInstr", "*", "AMDGPUInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "R600", "0" ]

[]

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

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "static", "void", "m32r_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "if", "(", "no_rtl", ")", "return", ";", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "first_anon_arg", "=", "(", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "mode", ",", "type", ")", ")", ";", "if", "(", "first_anon_arg", "<", "M32R_MAX_PARM_REGS", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "int", "size", "=", "M32R_MAX_PARM_REGS", "-", "first_reg_offset", ";", "rtx", "regblock", ";", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "set_mem_alias_set", "(", "regblock", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "size", ")", ";", "*", "pretend_size", "=", "(", "size", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "M32R", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "m32r", "0" ]

[]

[ "<s>", "void", "LEGAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "LEG", "LEG" ]

[]

[ "<s>", "bool", "MipsInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "GCNTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "CommonTTI", ".", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "a", "symbol", "reference" ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"C64x+ specific post RA scheduler\"", ";", "}", "</s>" ]

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

[ "TMS320C64X", "\"C64x+ specific post RA scheduler\"" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "dump", "(", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "dbgs", "(", ")", "<<", "\"Registers: \"", ";", "bool", "First", "=", "true", ";", "for", "(", "Register", "Reg", ":", "Edges", ")", "{", "if", "(", "!", "First", ")", "dbgs", "(", ")", "<<", "\", \"", ";", "First", "=", "false", ";", "dbgs", "(", ")", "<<", "printReg", "(", "Reg", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ",", "0", ",", "MRI", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", "<<", "\"Instructions:\"", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Instrs", ")", "{", "dbgs", "(", ")", "<<", "\"\\n \"", ";", "MI", "->", "print", "(", "dbgs", "(", ")", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "X86", "\"Registers: \"", "\", \"", "0", "\"\\n\"", "\"Instructions:\"", "\"\\n \"", "\"\\n\"" ]

[]

[ "<s>", "static", "int", "aarch64_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "const", "cpu_vector_cost", "*", "costs", "=", "aarch64_tune_params", ".", "vec_costs", ";", "bool", "fp", "=", "false", ";", "if", "(", "vectype", "!=", "NULL", ")", "fp", "=", "FLOAT_TYPE_P", "(", "vectype", ")", ";", "const", "simd_vec_cost", "*", "simd_costs", "=", "aarch64_simd_vec_costs", "(", "vectype", ")", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "fp", "?", "costs", "->", "scalar_fp_stmt_cost", ":", "costs", "->", "scalar_int_stmt_cost", ";", "case", "scalar_load", ":", "return", "costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "fp", "?", "simd_costs", "->", "fp_stmt_cost", ":", "simd_costs", "->", "int_stmt_cost", ";", "case", "vector_load", ":", "return", "simd_costs", "->", "align_load_cost", ";", "case", "vector_store", ":", "return", "simd_costs", "->", "store_cost", ";", "case", "vec_to_scalar", ":", "return", "simd_costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "simd_costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "case", "vector_gather_load", ":", "return", "simd_costs", "->", "unalign_load_cost", ";", "case", "unaligned_store", ":", "case", "vector_scatter_store", ":", "return", "simd_costs", "->", "unalign_store_cost", ";", "case", "cond_branch_taken", ":", "return", "costs", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "costs", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "return", "simd_costs", "->", "permute_cost", ";", "case", "vec_promote_demote", ":", "return", "fp", "?", "simd_costs", "->", "fp_stmt_cost", ":", "simd_costs", "->", "int_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "estimated_poly_value", "(", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

[ "aarch64", "2", "1" ]

[]

[ "<s>", "const", "MCSection", "*", "AMDGPUMCAsmInfo", "::", "getNonexecutableStackSection", "(", "MCContext", "&", "CTX", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "R600" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "MCB", ";", "MCB", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ";", "unsigned", "IgnoreCount", "=", "0", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "{", "if", "(", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MII", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "++", "IgnoreCount", ";", "else", "{", "HexagonLowerToMC", "(", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "}", "}", "else", "{", "HexagonLowerToMC", "(", "MI", ",", "MCB", ",", "*", "this", ")", ";", "HexagonMCInstrInfo", "::", "padEndloop", "(", "MCB", ")", ";", "}", "HexagonMCInstrInfo", "::", "tryCompound", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ")", ";", "SmallVector", "<", "DuplexCandidate", ",", "8", ">", "possibleDuplexes", ";", "possibleDuplexes", "=", "HexagonMCInstrInfo", "::", "getDuplexPossibilties", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "MCB", ")", ";", "HexagonMCShuffle", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "possibleDuplexes", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCB", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "0", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "aarch64_madd_needs_nop", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_type", "attr_type", ";", "rtx_insn", "*", "prev", ";", "rtx", "body", ";", "if", "(", "!", "TARGET_FIX_ERR_A53_835769", ")", "return", "false", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "attr_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "!", "is_madd_op", "(", "attr_type", ")", ")", "return", "false", ";", "prev", "=", "aarch64_prev_real_insn", "(", "insn", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "contains_mem_rtx_p", "(", "PATTERN", "(", "prev", ")", ")", ")", "return", "false", ";", "body", "=", "single_set", "(", "prev", ")", ";", "if", "(", "GET_MODE", "(", "recog_data", ".", "operand", "[", "0", "]", ")", "==", "DImode", "&&", "(", "!", "body", "||", "!", "dep_between_memop_and_curr", "(", "body", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "When", "working", "around", "the", "Cortex-A53", "erratum", "835769", ",", "given", "rtx_insn", "INSN", ",", "return", "true", "if", "it", "is", "a", "64-bit", "multiply-accumulate", "instruction", "and", "has", "a", "preceding", "memory", "instruction", "such", "that", "a", "NOP", "should", "be", "inserted", "between", "them", "." ]

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

[]

[ "<s>", "X86TargetLowering", "::", "ConstraintType", "X86TargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'R'", ":", "case", "'q'", ":", "case", "'Q'", ":", "case", "'f'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'y'", ":", "case", "'x'", ":", "case", "'Y'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'c'", ":", "case", "'d'", ":", "case", "'S'", ":", "case", "'D'", ":", "case", "'A'", ":", "return", "C_Register", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'G'", ":", "case", "'C'", ":", "case", "'e'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "X86", "X86", "X86", "1", "0" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "loadImmediate", "(", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "DebugLoc", "DL", ",", "unsigned", "*", "NewImm", ")", "const", "{", "MipsAnalyzeImmediate", "AnalyzeImm", ";", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "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", ";", "unsigned", "ATReg", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "AT_64", ":", "Mips", "::", "AT", ";", "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", ")", ")", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "LUi", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "LUi", ")", ",", "ATReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "ATReg", ")", ".", "addReg", "(", "ZEROReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", "-", "LastInstrIsADDiu", ";", "++", "Inst", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "ATReg", ")", ".", "addReg", "(", "ATReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "if", "(", "LastInstrIsADDiu", ")", "*", "NewImm", "=", "Inst", "->", "ImmOpnd", ";", "return", "ATReg", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "64", "32", "Mips::LUi64", "Mips::LUi", "Mips::ZERO_64", "Mips::ZERO", "Mips::AT_64", "Mips::AT", "Mips", "Mips", "1", "16", "16", "16" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "CallGraphResourceInfo", ".", "clear", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "*", "getGlobalSTI", "(", ")", ";", "if", "(", "AMDGPU", "::", "isGFX10", "(", "STI", ")", "&&", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitCodeEnd", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isGFX10" ]

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "pair", "<", "uint64_t", ",", "uint64_t", ">>", "X86MCInstrAnalysis", "::", "findPltEntries", "(", "uint64_t", "PltSectionVA", ",", "ArrayRef", "<", "uint8_t", ">", "PltContents", ",", "uint64_t", "GotPltSectionVA", ",", "const", "Triple", "&", "TargetTriple", ")", "const", "{", "switch", "(", "TargetTriple", ".", "getArch", "(", ")", ")", "{", "case", "Triple", "::", "x86", ":", "return", "findX86PltEntries", "(", "PltSectionVA", ",", "PltContents", ",", "GotPltSectionVA", ")", ";", "case", "Triple", "::", "x86_64", ":", "return", "findX86_64PltEntries", "(", "PltSectionVA", ",", "PltContents", ")", ";", "default", ":", "return", "{", "}", ";", "}", "}", "</s>" ]

[ "Returns", "(", "PLT", "virtual", "address", ",", "GOT", "virtual", "address", ")", "pairs", "for", "PLT", "entries", "." ]

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

[]

[ "<s>", "static", "pad_direction", "arm_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "TARGET_AAPCS_BASED", ")", "return", "default_function_arg_padding", "(", "mode", ",", "type", ")", ";", "if", "(", "type", "&&", "BYTES_BIG_ENDIAN", "&&", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "return", "PAD_DOWNWARD", ";", "return", "PAD_UPWARD", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_PADDING", ";", "return", "PAD_UPWARD", "if", "the", "lowest", "byte", "of", "a", "stack", "argument", "has", "useful", "data", ".", "For", "legacy", "APCS", "ABIs", "we", "use", "the", "default", ".", "For", "AAPCS", "based", "ABIs", "small", "aggregate", "types", "are", "placed", "in", "the", "lowest", "memory", "address", "." ]

[ "arm" ]

[]

[ "<s>", "static", "rtx", "v850_all_frame_related", "(", "rtx", "par", ")", "{", "int", "len", "=", "XVECLEN", "(", "par", ",", "0", ")", ";", "int", "i", ";", "gcc_assert", "(", "GET_CODE", "(", "par", ")", "==", "PARALLEL", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "F", "(", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "Mark", "all", "the", "subexpressions", "of", "the", "PARALLEL", "rtx", "PAR", "as", "frame-related", ".", "Return", "PAR", ".", "dwarf2out.cc", ":", "dwarf2out_frame_debug_expr", "ignores", "sub-expressions", "of", "a", "PARALLEL", "rtx", "other", "than", "the", "first", "if", "they", "do", "not", "have", "the", "FRAME_RELATED", "flag", "set", "on", "them", "." ]

[ "v850", "0", "0", "0" ]

[]

[ "<s>", "bool", "MSP430PassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createMSP430ISelDag", "(", "getMSP430TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "CallInst", "&", "CI", ",", "unsigned", "CalleeReg", ",", "unsigned", "ResReg", ",", "ArrayRef", "<", "unsigned", ">", "ArgRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "MVT", ",", "8", ">", "ArgTys", ";", "for", "(", "auto", "&", "Arg", ":", "CI", ".", "arg_operands", "(", ")", ")", "ArgTys", ".", "push_back", "(", "MVT", "::", "getVT", "(", "Arg", "->", "getType", "(", ")", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "CallAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "PhysRegs", ";", "handleAssignments", "(", "MIRBuilder", ",", "CallAssignFn", ",", "ArgTys", ",", "ArgRegs", ",", "[", "&", "]", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "unsigned", "ValReg", ",", "unsigned", "PhysReg", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValReg", ")", ";", "PhysRegs", ".", "push_back", "(", "PhysReg", ")", ";", "}", ")", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "CalleeReg", ")", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "AArch64", "::", "BLR", ")", ".", "addUse", "(", "CalleeReg", ")", ";", "else", "MIB", "=", "MIRBuilder", ".", "buildInstr", "(", "AArch64", "::", "BL", ")", ".", "addGlobalAddress", "(", "CI", ".", "getCalledFunction", "(", ")", ")", ";", "auto", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "F", ".", "getCallingConv", "(", ")", ")", ")", ";", "for", "(", "auto", "Reg", ":", "PhysRegs", ")", "MIB", ".", "addUse", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "CCAssignFn", "*", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "if", "(", "!", "CI", ".", "getType", "(", ")", "->", "isVoidTy", "(", ")", ")", "handleAssignments", "(", "MIRBuilder", ",", "RetAssignFn", ",", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ",", "ResReg", ",", "[", "&", "]", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "unsigned", "ValReg", ",", "unsigned", "PhysReg", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "ValReg", ",", "PhysReg", ")", ";", "MIB", ".", "addDef", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "AArch64", "AArch64", "8", "MVT::getVT", "AArch64", "AArch64", "8", "AArch64::BLR", "AArch64::BL", "MVT::getVT" ]

[]

[ "<s>", "bool", "ARMOptimizeBarriersPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "std", "::", "vector", "<", "MachineInstr", "*", ">", "ToRemove", ";", "int64_t", "DMBType", "=", "-", "1", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "IsRemovableNextDMB", "=", "false", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "DMB", ")", "{", "if", "(", "IsRemovableNextDMB", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "DMBType", ")", "{", "ToRemove", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "{", "IsRemovableNextDMB", "=", "true", ";", "DMBType", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "if", "(", "!", "CanMovePastDMB", "(", "&", "MI", ")", ")", "{", "IsRemovableNextDMB", "=", "false", ";", "}", "}", "}", "for", "(", "auto", "MI", ":", "ToRemove", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumDMBsRemoved", ";", "}", "return", "NumDMBsRemoved", ">", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "ARM::DMB", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "visitInstruction", "(", "Instruction", "&", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Specify", "what", "to", "return", "for", "unhandled", "instructions", "." ]

[ "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "ashlqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsl %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0xf0\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xe0\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xc0\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"ror %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"ror %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error. Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsl %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "8bit", "shift", "left", "(", "(", "char", ")", "x", "<", "<", "i", ")" ]

[ "avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsl %0\"", "2", "2", "\"lsl %0\"", "\"lsl %0\"", "3", "3", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0xf0\"", "4", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "5", "0", "3", "\"swap %0\"", "\"lsl %0\"", "\"andi %0,0xe0\"", "5", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "6", "0", "4", "\"swap %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"andi %0,0xc0\"", "6", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "7", "3", "\"ror %0\"", "\"clr %0\"", "\"ror %0\"", "2", "\"internal compiler error. Incorrect shift:\"", "\"lsl %0\"", "1", "\"\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ",", "bool", "&", "UseOneConstNR", ",", "bool", "Reciprocal", ")", "const", "{", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasFRSQRTES", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", ".", "hasFRSQRTE", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasAltivec", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f64", "&&", "Subtarget", ".", "hasQPX", "(", ")", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "getEstimateRefinementSteps", "(", "VT", ",", "Subtarget", ")", ";", "UseOneConstNR", "=", "true", ";", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "FRSQRTE", ",", "SDLoc", "(", "Operand", ")", ",", "VT", ",", "Operand", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::v4f32", "MVT::v2f64", "MVT::v4f32", "MVT::v4f64", "PPCISD::FRSQRTE" ]

[]

[ "<s>", "bool", "rs6000_function_pcrel_p", "(", "struct", "function", "*", "fn", ")", "{", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", ")", "return", "false", ";", "if", "(", "fn", "==", "cfun", ")", "return", "(", "(", "rs6000_isa_flags", "&", "OPTION_MASK_PCREL", ")", "!=", "0", "&&", "TARGET_CMODEL", "==", "CMODEL_MEDIUM", ")", ";", "return", "rs6000_fndecl_pcrel_p", "(", "fn", "->", "decl", ")", ";", "}", "</s>" ]

[ "Return", "whether", "we", "should", "generate", "PC-relative", "code", "for", "*", "FN", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "SIFixWWMLiveness", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "EXIT_WWM", ")", "{", "Modified", "|=", "runOnWWMInstruction", "(", "MI", ")", ";", "}", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::EXIT_WWM" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCStreamer", "*", "S", ")", "{", "return", "S", "->", "getKind", "(", ")", "==", "SK_MipsELFStreamer", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "PatmosSubtarget", "::", "getIssueWidth", "(", "unsigned", "SchedClass", ")", "const", "{", "return", "InstrItins", ".", "getNumMicroOps", "(", "SchedClass", ")", ";", "}", "</s>" ]

[ "Maximum", "number", "of", "micro-ops", "that", "may", "be", "scheduled", "per", "cycle", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "void", "AMDGPUArgumentUsageInfo", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "Module", "*", "M", ")", "const", "{", "for", "(", "const", "auto", "&", "FI", ":", "ArgInfoMap", ")", "{", "OS", "<<", "\"Arguments for \"", "<<", "FI", ".", "first", "->", "getName", "(", ")", "<<", "'\\n'", "<<", "\" PrivateSegmentBuffer: \"", "<<", "FI", ".", "second", ".", "PrivateSegmentBuffer", "<<", "\" DispatchPtr: \"", "<<", "FI", ".", "second", ".", "DispatchPtr", "<<", "\" QueuePtr: \"", "<<", "FI", ".", "second", ".", "QueuePtr", "<<", "\" KernargSegmentPtr: \"", "<<", "FI", ".", "second", ".", "KernargSegmentPtr", "<<", "\" DispatchID: \"", "<<", "FI", ".", "second", ".", "DispatchID", "<<", "\" FlatScratchInit: \"", "<<", "FI", ".", "second", ".", "FlatScratchInit", "<<", "\" PrivateSegmentSize: \"", "<<", "FI", ".", "second", ".", "PrivateSegmentSize", "<<", "\" WorkGroupIDX: \"", "<<", "FI", ".", "second", ".", "WorkGroupIDX", "<<", "\" WorkGroupIDY: \"", "<<", "FI", ".", "second", ".", "WorkGroupIDY", "<<", "\" WorkGroupIDZ: \"", "<<", "FI", ".", "second", ".", "WorkGroupIDZ", "<<", "\" WorkGroupInfo: \"", "<<", "FI", ".", "second", ".", "WorkGroupInfo", "<<", "\" PrivateSegmentWaveByteOffset: \"", "<<", "FI", ".", "second", ".", "PrivateSegmentWaveByteOffset", "<<", "\" ImplicitBufferPtr: \"", "<<", "FI", ".", "second", ".", "ImplicitBufferPtr", "<<", "\" ImplicitArgPtr: \"", "<<", "FI", ".", "second", ".", "ImplicitArgPtr", "<<", "\" WorkItemIDX \"", "<<", "FI", ".", "second", ".", "WorkItemIDX", "<<", "\" WorkItemIDY \"", "<<", "FI", ".", "second", ".", "WorkItemIDY", "<<", "\" WorkItemIDZ \"", "<<", "FI", ".", "second", ".", "WorkItemIDZ", "<<", "'\\n'", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Arguments for \"", "\" PrivateSegmentBuffer: \"", "\" DispatchPtr: \"", "\" QueuePtr: \"", "\" KernargSegmentPtr: \"", "\" DispatchID: \"", "\" FlatScratchInit: \"", "\" PrivateSegmentSize: \"", "\" WorkGroupIDX: \"", "\" WorkGroupIDY: \"", "\" WorkGroupIDZ: \"", "\" WorkGroupInfo: \"", "\" PrivateSegmentWaveByteOffset: \"", "\" ImplicitBufferPtr: \"", "\" ImplicitArgPtr: \"", "\" WorkItemIDX \"", "\" WorkItemIDY \"", "\" WorkItemIDZ \"" ]

[]

[ "<s>", "void", "tilepro_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "tilepro_in_bundle", ")", "{", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "fprintf", "(", "file", ",", "\"\\t{\\n\"", "\"\\tmove\\tr10, lr\\n\"", "\"\\tjal\\tplt(%s)\\n\"", "\"\\t}\\n\"", ",", "MCOUNT_NAME", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\t{\\n\"", "\"\\tmove\\tr10, lr\\n\"", "\"\\tjal\\t%s\\n\"", "\"\\t}\\n\"", ",", "MCOUNT_NAME", ")", ";", "}", "tilepro_in_bundle", "=", "false", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "FILE", "to", "increment", "profiler", "label", "#", "LABELNO", "for", "profiling", "a", "function", "entry", "." ]

[ "tilepro", "\"\\t}\\n\"", "\"\\t{\\n\"", "\"\\tmove\\tr10, lr\\n\"", "\"\\tjal\\tplt(%s)\\n\"", "\"\\t}\\n\"", "\"\\t{\\n\"", "\"\\tmove\\tr10, lr\\n\"", "\"\\tjal\\t%s\\n\"", "\"\\t}\\n\"" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "CCFunction", ")", ";", "if", "(", "CallConv", "!=", "CallingConv", "::", "AVR_BUILTIN", "&&", "RVLocs", ".", "size", "(", ")", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "for", "(", "CCValAssign", "const", "&", "RVLoc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLoc", ".", "getLocReg", "(", ")", ",", "RVLoc", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "ix86_builtin_tm_load", "(", "tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "switch", "(", "tree_to_uhwi", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "{", "case", "64", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_LOAD_M64", ")", ";", "case", "128", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_LOAD_M128", ")", ";", "case", "256", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_LOAD_M256", ")", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "the", "builtin", "decl", "needed", "to", "load", "a", "vector", "of", "TYPE", "." ]

[ "i386", "64", "128", "256" ]

[]

[ "<s>", "static", "void", "consume_whitespace", "(", "void", ")", "{", "while", "(", "pos", "<", "LINELEN", "&&", "isspace", "(", "linebuf", "[", "pos", "]", ")", "&&", "linebuf", "[", "pos", "]", "!=", "'\\n'", ")", "pos", "++", ";", "if", "(", "pos", ">=", "LINELEN", ")", "{", "diag", "(", "pos", ",", "\"line length overrun.\\n\"", ")", ";", "exit", "(", "1", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Pass", "over", "whitespace", "(", "other", "than", "a", "newline", ",", "which", "terminates", "the", "scan", ")", "." ]

[ "rs6000", "\"line length overrun.\\n\"", "1" ]

[]

[ "<s>", "static", "void", "copy_fp_args", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "link", ";", "rtx", "xoperands", "[", "2", "]", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "int", "arg_mode", ",", "regno", ";", "rtx", "use", "=", "XEXP", "(", "link", ",", "0", ")", ";", "if", "(", "!", "(", "GET_CODE", "(", "use", ")", "==", "USE", "&&", "GET_CODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", "==", "REG", "&&", "FUNCTION_ARG_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ")", ")", ")", "continue", ";", "arg_mode", "=", "GET_MODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "if", "(", "regno", ">=", "32", "&&", "regno", "<=", "39", ")", "{", "if", "(", "arg_mode", "==", "SFmode", ")", "{", "xoperands", "[", "0", "]", "=", "XEXP", "(", "use", ",", "0", ")", ";", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "26", "-", "(", "regno", "-", "32", ")", "/", "2", ")", ";", "output_asm_insn", "(", "\"{fstws|fstw} %0,-16(%%sr0,%%r30)\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -16(%%sr0,%%r30),%1\"", ",", "xoperands", ")", ";", "}", "else", "{", "xoperands", "[", "0", "]", "=", "XEXP", "(", "use", ",", "0", ")", ";", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "25", "-", "(", "regno", "-", "34", ")", "/", "2", ")", ";", "output_asm_insn", "(", "\"{fstds|fstd} %0,-16(%%sr0,%%r30)\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -12(%%sr0,%%r30),%R1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -16(%%sr0,%%r30),%1\"", ",", "xoperands", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Copy", "any", "FP", "arguments", "in", "INSN", "into", "integer", "registers", "." ]

[ "pa", "2", "1", "0", "0", "0", "0", "0", "32", "39", "0", "0", "1", "26", "32", "2", "\"{fstws|fstw} %0,-16(%%sr0,%%r30)\"", "\"ldw -16(%%sr0,%%r30),%1\"", "0", "0", "1", "25", "34", "2", "\"{fstds|fstd} %0,-16(%%sr0,%%r30)\"", "\"ldw -12(%%sr0,%%r30),%R1\"", "\"ldw -16(%%sr0,%%r30),%1\"" ]

[]

[ "<s>", "bool", "ThumbDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ")", "const", "{", "unsigned", "insn", "=", "0", ";", "uint16_t", "insn1", "=", "0", ";", "uint8_t", "bytes", "[", "2", "]", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "unsigned", "bits15_11", "=", "slice", "(", "insn", ",", "15", ",", "11", ")", ";", "bool", "IsThumb2", "=", "false", ";", "if", "(", "bits15_11", "==", "0x1D", "||", "bits15_11", "==", "0x1E", "||", "bits15_11", "==", "0x1F", ")", "{", "IsThumb2", "=", "true", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", "+", "2", ",", "2", ",", "(", "uint8_t", "*", ")", "bytes", ",", "NULL", ")", "==", "-", "1", ")", "return", "false", ";", "insn1", "=", "(", "bytes", "[", "1", "]", "<<", "8", ")", "|", "bytes", "[", "0", "]", ";", "insn", "=", "(", "insn", "<<", "16", "|", "insn1", ")", ";", "}", "unsigned", "Opcode", "=", "decodeThumbSideEffect", "(", "IsThumb2", ",", "insn", ")", ";", "ARMFormat", "Format", "=", "ARMFormats", "[", "Opcode", "]", ";", "Size", "=", "IsThumb2", "?", "4", ":", "2", ";", "DEBUG", "(", "{", "errs", "(", ")", "<<", "\"Opcode=\"", "<<", "Opcode", "<<", "\" Name=\"", "<<", "ARMUtils", "::", "OpcodeName", "(", "Opcode", ")", "<<", "\" Format=\"", "<<", "stringForARMFormat", "(", "Format", ")", "<<", "'('", "<<", "(", "int", ")", "Format", "<<", "\")\\n\"", ";", "showBitVector", "(", "errs", "(", ")", ",", "insn", ")", ";", "}", ")", ";", "ARMBasicMCBuilder", "*", "Builder", "=", "CreateMCBuilder", "(", "Opcode", ",", "Format", ")", ";", "if", "(", "!", "Builder", ")", "return", "false", ";", "Builder", "->", "SetSession", "(", "const_cast", "<", "Session", "*", ">", "(", "&", "SO", ")", ")", ";", "if", "(", "!", "Builder", "->", "Build", "(", "MI", ",", "insn", ")", ")", "return", "false", ";", "delete", "Builder", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "0", "0", "2", "2", "1", "1", "8", "0", "15", "11", "0x1D", "0x1E", "0x1F", "2", "2", "1", "1", "8", "0", "16", "ARM", "ARM", "4", "2", "\"Opcode=\"", "\" Name=\"", "ARMUtils::OpcodeName", "\" Format=\"", "ARM", "\")\\n\"", "ARM" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "sparc_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "MAX", "(", "align", ",", "FASTEST_ALIGNMENT", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", "." ]

[ "sparc" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "R600Subtarget", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "R600", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "&", "MI", ")", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", ".", "dump", "(", ")", ";", "}", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">>", "RemapChan", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "R600::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getExtractSubregLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "RegSubRegPairAndIdx", "&", "InputReg", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isExtractSubregLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VMOVRRD", ":", "const", "MachineOperand", "&", "MOReg", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "InputReg", ".", "Reg", "=", "MOReg", ".", "getReg", "(", ")", ";", "InputReg", ".", "SubReg", "=", "MOReg", ".", "getSubReg", "(", ")", ";", "InputReg", ".", "SubIdx", "=", "DefIdx", "==", "0", "?", "ARM", "::", "ssub_0", ":", "ARM", "::", "ssub_1", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getExtractSubregInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VMOVRRD", "2", "0", "ARM::ssub_0", "ARM::ssub_1", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "static", "void", "rs6000_emit_move_from_cr", "(", "rtx", "reg", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "TARGET_MFCRF", ")", "{", "int", "i", ",", "cr_reg", "[", "8", "]", ",", "count", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "cr_reg", "[", "count", "++", "]", "=", "i", ";", "if", "(", "count", "==", "1", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "1", ")", ";", "rtvec", "r", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "r", ",", "0", ")", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "cr_reg", "[", "0", "]", ")", ";", "RTVEC_ELT", "(", "r", ",", "1", ")", "=", "GEN_INT", "(", "1", "<<", "(", "7", "-", "cr_reg", "[", "0", "]", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "r", ",", "UNSPEC_MOVESI_FROM_CR", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "return", ";", "}", "}", "emit_insn", "(", "gen_movesi_from_cr", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "store", "CR", "fields", "that", "need", "to", "be", "saved", "into", "REG", "." ]

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

[]

[ "<s>", "bool", "aarch64_emit_approx_sqrt", "(", "rtx", "dst", ",", "rtx", "src", ",", "bool", "recp", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "if", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "HFmode", ")", "{", "gcc_assert", "(", "!", "recp", ")", ";", "return", "false", ";", "}", "machine_mode", "mmsk", "=", "mode_for_vector", "(", "int_mode_for_mode", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ",", "GET_MODE_NUNITS", "(", "mode", ")", ")", ";", "if", "(", "!", "recp", ")", "{", "if", "(", "!", "(", "flag_mlow_precision_sqrt", "||", "(", "aarch64_tune_params", ".", "approx_modes", "->", "sqrt", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", ")", ")", "return", "false", ";", "if", "(", "flag_finite_math_only", "||", "flag_trapping_math", "||", "!", "flag_unsafe_math_optimizations", "||", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "false", ";", "}", "else", "gcc_assert", "(", "use_rsqrt_p", "(", "mode", ")", ")", ";", "rtx", "xmsk", "=", "gen_reg_rtx", "(", "mmsk", ")", ";", "if", "(", "!", "recp", ")", "emit_insn", "(", "gen_rtx_SET", "(", "xmsk", ",", "gen_rtx_NEG", "(", "mmsk", ",", "gen_rtx_EQ", "(", "mmsk", ",", "src", ",", "CONST0_RTX", "(", "mode", ")", ")", ")", ")", ")", ";", "rtx", "xdst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "(", "*", "get_rsqrte_type", "(", "mode", ")", ")", "(", "xdst", ",", "src", ")", ")", ";", "int", "iterations", "=", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "DFmode", ")", "?", "3", ":", "2", ";", "if", "(", "(", "recp", "&&", "flag_mrecip_low_precision_sqrt", ")", "||", "(", "!", "recp", "&&", "flag_mlow_precision_sqrt", ")", ")", "iterations", "--", ";", "rtx", "x1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "while", "(", "iterations", "--", ")", "{", "rtx", "x2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_set_insn", "(", "x2", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "xdst", ")", ")", ";", "emit_insn", "(", "(", "*", "get_rsqrts_type", "(", "mode", ")", ")", "(", "x1", ",", "src", ",", "x2", ")", ")", ";", "if", "(", "iterations", ">", "0", ")", "emit_set_insn", "(", "xdst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "x1", ")", ")", ";", "}", "if", "(", "!", "recp", ")", "{", "rtx", "xtmp", "=", "gen_reg_rtx", "(", "mmsk", ")", ";", "emit_set_insn", "(", "xtmp", ",", "gen_rtx_AND", "(", "mmsk", ",", "gen_rtx_NOT", "(", "mmsk", ",", "xmsk", ")", ",", "gen_rtx_SUBREG", "(", "mmsk", ",", "xdst", ",", "0", ")", ")", ")", ";", "emit_move_insn", "(", "xdst", ",", "gen_rtx_SUBREG", "(", "mode", ",", "xtmp", ",", "0", ")", ")", ";", "emit_set_insn", "(", "xdst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "src", ")", ")", ";", "}", "emit_set_insn", "(", "dst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "x1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "instruction", "sequence", "to", "compute", "either", "the", "approximate", "square", "root", "or", "its", "approximate", "reciprocal", ",", "depending", "on", "the", "flag", "RECP", ",", "and", "return", "whether", "the", "sequence", "was", "emitted", "or", "not", "." ]

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

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSTRspi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegClass", "ARM", "ARM::tSTRspi", "0" ]

[]

[ "<s>", "static", "int", "function_arg_advance_32", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "bytes", ",", "HOST_WIDE_INT", "words", ")", "{", "int", "res", "=", "0", ";", "bool", "error_p", "=", "false", ";", "if", "(", "TARGET_IAMCU", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "bytes", "<=", "8", ")", "goto", "pass_in_reg", ";", "return", "res", ";", "}", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_BLKmode", ":", "if", "(", "bytes", "<", "0", ")", "break", ";", "case", "E_DImode", ":", "case", "E_SImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "pass_in_reg", ":", "cum", "->", "words", "+=", "words", ";", "cum", "->", "nregs", "-=", "words", ";", "cum", "->", "regno", "+=", "words", ";", "if", "(", "cum", "->", "nregs", ">=", "0", ")", "res", "=", "words", ";", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cfun", "->", "machine", "->", "arg_reg_available", "=", "false", ";", "cum", "->", "regno", "=", "0", ";", "}", "break", ";", "case", "E_OImode", ":", "gcc_unreachable", "(", ")", ";", "case", "E_DFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "2", ")", "break", ";", "case", "E_SFmode", ":", "if", "(", "cum", "->", "float_in_sse", "==", "-", "1", ")", "error_p", "=", "true", ";", "if", "(", "cum", "->", "float_in_sse", "<", "1", ")", "break", ";", "case", "E_V16HFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V64QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8DImode", ":", "case", "E_V32HFmode", ":", "case", "E_V16SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V32QImode", ":", "case", "E_V16HImode", ":", "case", "E_V4DFmode", ":", "case", "E_V4DImode", ":", "case", "E_TImode", ":", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V8HFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "cum", "->", "sse_words", "+=", "words", ";", "cum", "->", "sse_nregs", "-=", "1", ";", "cum", "->", "sse_regno", "+=", "1", ";", "if", "(", "cum", "->", "sse_nregs", "<=", "0", ")", "{", "cum", "->", "sse_nregs", "=", "0", ";", "cum", "->", "sse_regno", "=", "0", ";", "}", "}", "break", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V4HFmode", ":", "case", "E_V2SImode", ":", "case", "E_V2SFmode", ":", "case", "E_V1TImode", ":", "case", "E_V1DImode", ":", "if", "(", "!", "type", "||", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "cum", "->", "mmx_words", "+=", "words", ";", "cum", "->", "mmx_nregs", "-=", "1", ";", "cum", "->", "mmx_regno", "+=", "1", ";", "if", "(", "cum", "->", "mmx_nregs", "<=", "0", ")", "{", "cum", "->", "mmx_nregs", "=", "0", ";", "cum", "->", "mmx_regno", "=", "0", ";", "}", "}", "break", ";", "}", "if", "(", "error_p", ")", "{", "cum", "->", "float_in_sse", "=", "0", ";", "error", "(", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", ",", "cum", "->", "decl", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")", "Return", "a", "number", "of", "integer", "regsiters", "advanced", "over", "." ]

[ "i386", "0", "8", "0", "0", "0", "0", "0", "1", "2", "1", "1", "1", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"" ]

[]

[ "<s>", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyLocalOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_F64", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyLocalOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_LOCAL_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_LOCAL_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_LOCAL_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_LOCAL_F64", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".arch\"", ")", "parseDirectiveArch", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cpu\"", ")", "parseDirectiveCPU", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "parseDirectiveLtorg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".unreq\"", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".inst\"", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_negate_ra_state\"", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_b_key_frame\"", ")", "parseDirectiveCFIBKeyFrame", "(", ")", ";", "else", "if", "(", "IsMachO", ")", "{", "if", "(", "IDVal", "==", "MCLOHDirectiveName", "(", ")", ")", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\".arch\"", "\".cpu\"", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"", "\".cfi_negate_ra_state\"", "\".cfi_b_key_frame\"" ]

[]

[ "<s>", "RCPair", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'h'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "hGPRRegClass", ")", ";", "break", ";", "case", "'r'", ":", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_8RegClass", ")", ";", "break", ";", "case", "'t'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM", "::", "CPSR", ")", ",", "&", "ARM", "::", "CCRRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "0U", "ARM::hGPRRegClass", "0U", "ARM::GPRRegClass", "MVT::f32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPRRegClass", "128", "0U", "ARM::QPRRegClass", "MVT::f32", "0U", "ARM::SPR_8RegClass", "64", "0U", "ARM::DPR_8RegClass", "128", "0U", "ARM::QPR_8RegClass", "MVT::f32", "0U", "ARM::SPRRegClass", "\"{cc}\"", "ARM::CPSR", "ARM::CCRRegClass" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createAArch64ExpandPseudoPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64SpeculationHardeningPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorHWPFFixPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_base_register_rtx_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "contains_reg_of_mode", "[", "GENERAL_REGS", "]", "[", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", "]", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "aarch64_regno_ok_for_base_p", "(", "REGNO", "(", "x", ")", ",", "strict_p", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "base", "register", "for", "mode", "MODE", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "Mips", "::", "T0", ",", "Reg", ",", "true", ")", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "UseMI", ",", "DL", ",", "Reg", ",", "Mips", "::", "T0", ",", "true", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "Mips", "Mips", "Mips::T0", "Mips::T0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "&", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "PPC" ]

[]

[ "<s>", "static", "bool", "aarch64_process_one_target_attr", "(", "char", "*", "arg_str", ")", "{", "bool", "invert", "=", "false", ";", "size_t", "len", "=", "strlen", "(", "arg_str", ")", ";", "if", "(", "len", "==", "0", ")", "{", "error", "(", "\"malformed %<target()%> pragma or attribute\"", ")", ";", "return", "false", ";", "}", "char", "*", "str_to_check", "=", "(", "char", "*", ")", "alloca", "(", "len", "+", "1", ")", ";", "strcpy", "(", "str_to_check", ",", "arg_str", ")", ";", "if", "(", "*", "str_to_check", "==", "'+'", ")", "return", "aarch64_handle_attr_isa_flags", "(", "str_to_check", ")", ";", "if", "(", "len", ">", "3", "&&", "strncmp", "(", "str_to_check", ",", "\"no-\"", ",", "3", ")", "==", "0", ")", "{", "invert", "=", "true", ";", "str_to_check", "+=", "3", ";", "}", "char", "*", "arg", "=", "strchr", "(", "str_to_check", ",", "'='", ")", ";", "if", "(", "arg", ")", "{", "*", "arg", "=", "'\\0'", ";", "arg", "++", ";", "}", "const", "struct", "aarch64_attribute_info", "*", "p_attr", ";", "bool", "found", "=", "false", ";", "for", "(", "p_attr", "=", "aarch64_attributes", ";", "p_attr", "->", "name", ";", "p_attr", "++", ")", "{", "if", "(", "strcmp", "(", "str_to_check", ",", "p_attr", "->", "name", ")", "!=", "0", ")", "continue", ";", "found", "=", "true", ";", "bool", "attr_need_arg_p", "=", "p_attr", "->", "attr_type", "==", "aarch64_attr_custom", "||", "p_attr", "->", "attr_type", "==", "aarch64_attr_enum", ";", "if", "(", "attr_need_arg_p", "^", "(", "arg", "!=", "NULL", ")", ")", "{", "error", "(", "\"pragma or attribute %<target(\\\"%s\\\")%> does not accept an argument\"", ",", "str_to_check", ")", ";", "return", "false", ";", "}", "if", "(", "invert", "&&", "!", "p_attr", "->", "allow_neg", ")", "{", "error", "(", "\"pragma or attribute %<target(\\\"%s\\\")%> does not allow a negated form\"", ",", "str_to_check", ")", ";", "return", "false", ";", "}", "switch", "(", "p_attr", "->", "attr_type", ")", "{", "case", "aarch64_attr_custom", ":", "gcc_assert", "(", "p_attr", "->", "handler", ")", ";", "if", "(", "!", "p_attr", "->", "handler", "(", "arg", ")", ")", "return", "false", ";", "break", ";", "case", "aarch64_attr_bool", ":", "{", "struct", "cl_decoded_option", "decoded", ";", "generate_option", "(", "p_attr", "->", "opt_num", ",", "NULL", ",", "!", "invert", ",", "CL_TARGET", ",", "&", "decoded", ")", ";", "aarch64_handle_option", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "decoded", ",", "input_location", ")", ";", "break", ";", "}", "case", "aarch64_attr_mask", ":", "{", "struct", "cl_decoded_option", "decoded", ";", "decoded", ".", "opt_index", "=", "p_attr", "->", "opt_num", ";", "decoded", ".", "value", "=", "!", "invert", ";", "aarch64_handle_option", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "decoded", ",", "input_location", ")", ";", "break", ";", "}", "case", "aarch64_attr_enum", ":", "{", "gcc_assert", "(", "arg", ")", ";", "bool", "valid", ";", "int", "value", ";", "valid", "=", "opt_enum_arg_to_value", "(", "p_attr", "->", "opt_num", ",", "arg", ",", "&", "value", ",", "CL_TARGET", ")", ";", "if", "(", "valid", ")", "{", "set_option", "(", "&", "global_options", ",", "NULL", ",", "p_attr", "->", "opt_num", ",", "value", ",", "NULL", ",", "DK_UNSPECIFIED", ",", "input_location", ",", "global_dc", ")", ";", "}", "else", "{", "error", "(", "\"pragma or attribute %<target(\\\"%s=%s\\\")%> is not valid\"", ",", "str_to_check", ",", "arg", ")", ";", "}", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "found", ";", "}", "</s>" ]

[ "Parse", "ARG_STR", "which", "contains", "the", "definition", "of", "one", "target", "attribute", ".", "Show", "appropriate", "errors", "if", "any", "or", "return", "true", "if", "the", "attribute", "is", "valid", ".", "PRAGMA_OR_ATTR", "holds", "the", "string", "to", "use", "in", "error", "messages", "about", "whether", "we", "'re", "processing", "a", "target", "attribute", "or", "pragma", "." ]

[ "aarch64", "0", "\"malformed %<target()%> pragma or attribute\"", "1", "3", "\"no-\"", "3", "0", "3", "0", "\"pragma or attribute %<target(\\\"%s\\\")%> does not accept an argument\"", "\"pragma or attribute %<target(\\\"%s\\\")%> does not allow a negated form\"", "\"pragma or attribute %<target(\\\"%s=%s\\\")%> is not valid\"" ]

[]

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

[ "Returns", "true", "if", "the", "handler", "is", "dealing", "with", "incoming", "arguments", ",", "i.e", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "bpf_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "mode", "==", "FUNCTION_MODE", ")", ";", "case", "REG", ":", "return", "bpf_address_base_p", "(", "x", ",", "strict", ")", ";", "case", "PLUS", ":", "{", "rtx", "x0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "bpf_address_base_p", "(", "x0", ",", "strict", ")", "&&", "GET_CODE", "(", "x1", ")", "==", "CONST_INT", ")", "return", "IN_RANGE", "(", "INTVAL", "(", "x1", ")", ",", "-", "1", "-", "0x7fff", ",", "0x7fff", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "(", "a", "RTX", ")", "is", "a", "legitimate", "memory", "address", "on", "the", "target", "machine", "for", "a", "memory", "operand", "of", "mode", "MODE", "." ]

[ "bpf", "0", "1", "1", "0x7fff", "0x7fff" ]

[]

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

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

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

[]

[ "<s>", "bool", "AMDGPUAnnotateUniformValues", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "MDR", "=", "&", "getAnalysis", "<", "MemoryDependenceWrapperPass", ">", "(", ")", ".", "getMemDep", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "isKernelFunc", "=", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_KERNEL", ";", "visit", "(", "F", ")", ";", "noClobberClones", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", "||", "!", "Inst", ".", "getOperand", "(", "0", ")", ".", "isImm", "(", ")", "||", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "APInt", "SignedOffset", "(", "18", ",", "Imm", "*", "4", ",", "true", ")", ";", "Target", "=", "(", "SignedOffset", ".", "sext", "(", "64", ")", "+", "Addr", "+", "Size", ")", ".", "getZExtValue", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "AMDGPU", "0", "0", "0", "0", "18", "4", "64" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "MOVCCr", ":", "case", "ARM", "::", "t2MOVCCr", ":", "{", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "CC", "=", "getInstrPredicate", "(", "MI", ",", "PredReg", ")", ";", "if", "(", "CC", "==", "ARMCC", "::", "AL", "||", "PredReg", "!=", "ARM", "::", "CPSR", ")", "return", "NULL", ";", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "if", "(", "!", "MI", ")", "return", "NULL", ";", "MI", "->", "getOperand", "(", "MI", "->", "findFirstPredOperandIdx", "(", ")", ")", ".", "setImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "CC", ")", ")", ";", "return", "MI", ";", "}", "}", "return", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "0", "ARMCC::CondCodes", "ARMCC::AL", "ARM::CPSR", "ARMCC::getOppositeCondition" ]

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "B", "||", "Opc", "==", "ARM", "::", "tB", ")", "{", "MI", "->", "setDesc", "(", "get", "(", "Opc", "==", "ARM", "::", "B", "?", "ARM", "::", "Bcc", ":", "ARM", "::", "tBcc", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Pred", "[", "1", "]", ".", "getReg", "(", ")", ",", "false", ")", ")", ";", "return", "true", ";", "}", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", "->", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setImm", "(", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "PIdx", "+", "1", ")", ".", "setReg", "(", "Pred", "[", "1", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "ARM", "ARM", "ARM::B", "ARM::tB", "ARM::B", "ARM::Bcc", "ARM::tBcc", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "i386_pe_declare_function_type", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "int", "public", ")", "{", "fprintf", "(", "file", ",", "\"\\t.def\\t\"", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\";\\t.scl\\t%d;\\t.type\\t%d;\\t.endef\\n\"", ",", "public", "?", "(", "int", ")", "C_EXT", ":", "(", "int", ")", "C_STAT", ",", "(", "int", ")", "DT_FCN", "<<", "N_BTSHFT", ")", ";", "}", "</s>" ]

[ "Mark", "a", "function", "appropriately", ".", "This", "should", "only", "be", "called", "for", "functions", "for", "which", "we", "are", "not", "emitting", "COFF", "debugging", "information", ".", "FILE", "is", "the", "assembler", "output", "file", ",", "NAME", "is", "the", "name", "of", "the", "function", ",", "and", "PUBLIC", "is", "nonzero", "if", "the", "function", "is", "globally", "visible", "." ]

[ "i386", "\"\\t.def\\t\"", "\";\\t.scl\\t%d;\\t.type\\t%d;\\t.endef\\n\"" ]

[]

[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_vector_or_tuple_type", "(", "unsigned", "int", "argno", ",", "unsigned", "int", "num_vectors", ")", "{", "tree", "actual", "=", "get_argument_type", "(", "argno", ")", ";", "if", "(", "actual", "==", "error_mark_node", ")", "return", "NUM_TYPE_SUFFIXES", ";", "for", "(", "unsigned", "int", "size_i", "=", "0", ";", "size_i", "<", "MAX_TUPLE_SIZE", ";", "++", "size_i", ")", "for", "(", "unsigned", "int", "suffix_i", "=", "0", ";", "suffix_i", "<", "NUM_TYPE_SUFFIXES", ";", "++", "suffix_i", ")", "{", "vector_type_index", "type_i", "=", "type_suffixes", "[", "suffix_i", "]", ".", "vector_type", ";", "tree", "type", "=", "acle_vector_types", "[", "size_i", "]", "[", "type_i", "]", ";", "if", "(", "type", "&&", "matches_type_p", "(", "type", ",", "actual", ")", ")", "{", "if", "(", "size_i", "+", "1", "==", "num_vectors", ")", "return", "type_suffix_index", "(", "suffix_i", ")", ";", "if", "(", "num_vectors", "==", "1", ")", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a single SVE vector rather than a tuple\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "else", "if", "(", "size_i", "==", "0", "&&", "type_i", "!=", "VECTOR_TYPE_svbool_t", ")", "error_at", "(", "location", ",", "\"passing single vector %qT to argument %d\"", "\" of %qE, which expects a tuple of %d vectors\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "num_vectors", ")", ";", "else", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a tuple of %d vectors\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "num_vectors", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "}", "if", "(", "num_vectors", "==", "1", ")", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects an SVE vector type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "else", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects an SVE tuple type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "single", "vector", "or", "a", "tuple", "of", "NUM_VECTORS", "vectors", ";", "NUM_VECTORS", "is", "1", "for", "the", "former", ".", "Return", "the", "associated", "type", "suffix", "on", "success", ",", "using", "TYPE_SUFFIX_b", "for", "predicates", ".", "Report", "an", "error", "and", "return", "NUM_TYPE_SUFFIXES", "on", "failure", "." ]

[ "aarch64", "0", "0", "1", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects a single SVE vector rather than a tuple\"", "1", "0", "\"passing single vector %qT to argument %d\"", "\" of %qE, which expects a tuple of %d vectors\"", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects a tuple of %d vectors\"", "1", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects an SVE vector type\"", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects an SVE tuple type\"", "1" ]

[]

[ "<s>", "Optional", "<", "Instruction", "*", ">", "AArch64TTIImpl", "::", "instCombineIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ")", "const", "{", "Intrinsic", "::", "ID", "IID", "=", "II", ".", "getIntrinsicID", "(", ")", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_sve_convert_from_svbool", ":", "return", "instCombineConvertFromSVBool", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "instCombineSVEDup", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup_x", ":", "return", "instCombineSVEDupX", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne", ":", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "instCombineSVECmpNE", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_rdffr", ":", "return", "instCombineRDFFR", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lasta", ":", "case", "Intrinsic", "::", "aarch64_sve_lastb", ":", "return", "instCombineSVELast", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "2", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "4", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "8", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntb", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "16", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_first", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_last", ":", "return", "instCombineSVEPTest", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "case", "Intrinsic", "::", "aarch64_sve_fmul", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_fadd", ":", "case", "Intrinsic", "::", "aarch64_sve_fsub", ":", "return", "instCombineSVEVectorBinOp", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_uunpklo", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpklo", ":", "return", "instCombineSVEUnpack", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tuple_get", ":", "return", "instCombineSVETupleGet", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_zip1", ":", "case", "Intrinsic", "::", "aarch64_sve_zip2", ":", "return", "instCombineSVEZip", "(", "IC", ",", "II", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "their", "own", "combinations", "for", "target-specific", "intrinsics", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "Intrinsic::aarch64_sve_convert_from_svbool", "Intrinsic::aarch64_sve_dup", "Intrinsic::aarch64_sve_dup_x", "Intrinsic::aarch64_sve_cmpne", "Intrinsic::aarch64_sve_cmpne_wide", "Intrinsic::aarch64_sve_rdffr", "Intrinsic::aarch64_sve_lasta", "Intrinsic::aarch64_sve_lastb", "Intrinsic::aarch64_sve_cntd", "2", "Intrinsic::aarch64_sve_cntw", "4", "Intrinsic::aarch64_sve_cnth", "8", "Intrinsic::aarch64_sve_cntb", "16", "Intrinsic::aarch64_sve_ptest_any", "Intrinsic::aarch64_sve_ptest_first", "Intrinsic::aarch64_sve_ptest_last", "Intrinsic::aarch64_sve_mul", "Intrinsic::aarch64_sve_fmul", "Intrinsic::aarch64_sve_fadd", "Intrinsic::aarch64_sve_fsub", "Intrinsic::aarch64_sve_tbl", "Intrinsic::aarch64_sve_uunpkhi", "Intrinsic::aarch64_sve_uunpklo", "Intrinsic::aarch64_sve_sunpkhi", "Intrinsic::aarch64_sve_sunpklo", "Intrinsic::aarch64_sve_tuple_get", "Intrinsic::aarch64_sve_zip1", "Intrinsic::aarch64_sve_zip2" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "&", "MI", ",", "std", "::", "set", "<", "unsigned", ">", "&", "UpdRegs", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting \"", "<<", "printMBBReference", "(", "*", "MI", ".", "getParent", "(", ")", ")", "<<", "\": \"", "<<", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "Register", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "bool", "ReadUndef", "=", "MD", ".", "isUndef", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "auto", "updateRegs", "=", "[", "&", "UpdRegs", "]", "(", "const", "MachineInstr", "&", "MI", ")", "->", "void", "{", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", ")", "UpdRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ";", "MachineOperand", "&", "ST", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "SF", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "ST", ".", "isReg", "(", ")", "&&", "SF", ".", "isReg", "(", ")", ")", "{", "RegisterRef", "RT", "(", "ST", ")", ";", "if", "(", "RT", "==", "RegisterRef", "(", "SF", ")", ")", "{", "updateRegs", "(", "MI", ")", ";", "MI", ".", "setDesc", "(", "HII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ";", "unsigned", "S", "=", "getRegState", "(", "ST", ")", ";", "while", "(", "MI", ".", "getNumOperands", "(", ")", ">", "1", ")", "MI", ".", "RemoveOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstrBuilder", "(", "MF", ",", "MI", ")", ".", "addReg", "(", "RT", ".", "Reg", ",", "S", ",", "RT", ".", "Sub", ")", ";", "return", "true", ";", "}", "}", "MachineInstr", "*", "TfrT", "=", "genCondTfrFor", "(", "ST", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ",", "ReadUndef", ",", "false", ")", ";", "MachineInstr", "*", "TfrF", "=", "genCondTfrFor", "(", "SF", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ",", "ReadUndef", ",", "true", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrT", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrF", ")", ";", "updateRegs", "(", "MI", ")", ";", "removeInstr", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]

[ "Hexagon", "Hexagon", "\"\\nsplitting \"", "\": \"", "0", "1", "2", "3", "1", "1" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

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

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

[ "MCS51" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "std", "::", "string", "NewOpcode", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Plus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'+'", ";", "Name", "=", "NewOpcode", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'-'", ";", "Name", "=", "NewOpcode", ";", "}", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Dot", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "if", "(", "Dot", "!=", "StringRef", "::", "npos", ")", "{", "SMLoc", "DotLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Dot", ")", ";", "StringRef", "DotStr", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "FISCInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "FISC", "::", "MOVi64", ":", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "const", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "bool", "DstIsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "auto", "Q1", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVZ", ")", ",", "DstReg", ")", ";", "auto", "Q2", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "auto", "Q3", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "auto", "Q4", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "const", "uint64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "Q1", "=", "Q1", ".", "addImm", "(", "Imm", "&", "0xffff", ")", ".", "addImm", "(", "0", ")", ";", "Q2", "=", "Q2", ".", "addImm", "(", "(", "Imm", ">>", "16", ")", "&", "0xffff", ")", ".", "addImm", "(", "1", ")", ";", "Q3", "=", "Q3", ".", "addImm", "(", "(", "Imm", ">>", "32", ")", "&", "0xffff", ")", ".", "addImm", "(", "2", ")", ";", "Q4", "=", "Q4", ".", "addImm", "(", "(", "Imm", ">>", "48", ")", "&", "0xffff", ")", ".", "addImm", "(", "3", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "const", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "Q1", "=", "Q1", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q1", ")", ".", "addImm", "(", "0", ")", ";", "Q2", "=", "Q2", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q2", ")", ".", "addImm", "(", "1", ")", ";", "Q3", "=", "Q3", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q3", ")", ".", "addImm", "(", "2", ")", ";", "Q4", "=", "Q4", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q4", ")", ".", "addImm", "(", "3", ")", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "}", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::MOVi64", "0", "0", "1", "FISC::MOVZ", "FISC::MOVK", "FISC::MOVK", "FISC::MOVK", "0xffff", "0", "16", "0xffff", "1", "32", "0xffff", "2", "48", "0xffff", "3", "FISCII::MO_Q1", "0", "FISCII::MO_Q2", "1", "FISCII::MO_Q3", "2", "FISCII::MO_Q4", "3" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"hexagonv4\"", ";", "if", "(", "CPUString", "==", "\"hexagonv4\"", ")", "{", "HexagonArchVersion", "=", "V4", ";", "}", "else", "if", "(", "CPUString", "==", "\"hexagonv5\"", ")", "{", "HexagonArchVersion", "=", "V5", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "}", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "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", "\"hexagonv4\"", "\"hexagonv4\"", "Hexagon", "\"hexagonv5\"", "Hexagon", "\"Unrecognized Hexagon processor version\"" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "&", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "MOVCCr", ":", "case", "ARM", "::", "t2MOVCCr", ":", "{", "unsigned", "PredReg", "=", "0", ";", "ARMCC", "::", "CondCodes", "CC", "=", "getInstrPredicate", "(", "MI", ",", "PredReg", ")", ";", "if", "(", "CC", "==", "ARMCC", "::", "AL", "||", "PredReg", "!=", "ARM", "::", "CPSR", ")", "return", "nullptr", ";", "MachineInstr", "*", "CommutedMI", "=", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "if", "(", "!", "CommutedMI", ")", "return", "nullptr", ";", "CommutedMI", "->", "getOperand", "(", "CommutedMI", "->", "findFirstPredOperandIdx", "(", ")", ")", ".", "setImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "CC", ")", ")", ";", "return", "CommutedMI", ";", "}", "}", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "0", "ARMCC::CondCodes", "ARMCC::AL", "ARM::CPSR", "ARMCC::getOppositeCondition" ]

[]

[ "<s>", "bool", "nios2_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "UNSPEC", "&&", "nios2_large_offset_p", "(", "XINT", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "return", "true", ";", "return", "!", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "SDValue", "getValue", "(", ")", "const", "{", "assert", "(", "hasValue", "(", ")", "&&", "\"Cannot get the value of a constant bit\"", ")", ";", "return", "V", ";", "}", "</s>" ]

[ "Return", "the", "contained", "Value", "." ]

[ "PowerPC", "\"Cannot get the value of a constant bit\"" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_contiguous_load_insn", "(", "insn_code", "icode", ")", "{", "machine_mode", "mem_mode", "=", "memory_vector_mode", "(", ")", ";", "add_output_operand", "(", "icode", ")", ";", "add_mem_operand", "(", "mem_mode", ",", "get_contiguous_base", "(", "mem_mode", ")", ")", ";", "add_input_operand", "(", "icode", ",", "args", "[", "0", "]", ")", ";", "if", "(", "GET_MODE_UNIT_BITSIZE", "(", "mem_mode", ")", "<", "type_suffix", "(", "0", ")", ".", "element_bits", ")", "add_input_operand", "(", "icode", ",", "CONSTM1_RTX", "(", "VNx16BImode", ")", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Use", "contiguous", "load", "INSN", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_print_options_internal", "(", "FILE", "*", "file", ",", "int", "indent", ",", "const", "char", "*", "string", ",", "HOST_WIDE_INT", "flags", ",", "const", "char", "*", "prefix", ",", "const", "struct", "rs6000_opt_mask", "*", "opts", ",", "size_t", "num_elements", ")", "{", "size_t", "i", ";", "size_t", "start_column", "=", "0", ";", "size_t", "cur_column", ";", "size_t", "max_column", "=", "120", ";", "size_t", "prefix_len", "=", "strlen", "(", "prefix", ")", ";", "size_t", "comma_len", "=", "0", ";", "const", "char", "*", "comma", "=", "\"\"", ";", "if", "(", "indent", ")", "start_column", "+=", "fprintf", "(", "file", ",", "\"%*s\"", ",", "indent", ",", "\"\"", ")", ";", "if", "(", "!", "flags", ")", "{", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "string", ",", "\"<none>\"", ")", ";", "return", ";", "}", "start_column", "+=", "fprintf", "(", "stderr", ",", "DEBUG_FMT_WX", ",", "string", ",", "flags", ")", ";", "cur_column", "=", "start_column", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_elements", ";", "i", "++", ")", "{", "bool", "invert", "=", "opts", "[", "i", "]", ".", "invert", ";", "const", "char", "*", "name", "=", "opts", "[", "i", "]", ".", "name", ";", "const", "char", "*", "no_str", "=", "\"\"", ";", "HOST_WIDE_INT", "mask", "=", "opts", "[", "i", "]", ".", "mask", ";", "size_t", "len", "=", "comma_len", "+", "prefix_len", "+", "strlen", "(", "name", ")", ";", "if", "(", "!", "invert", ")", "{", "if", "(", "(", "flags", "&", "mask", ")", "==", "0", ")", "{", "no_str", "=", "\"no-\"", ";", "len", "+=", "strlen", "(", "\"no-\"", ")", ";", "}", "flags", "&=", "~", "mask", ";", "}", "else", "{", "if", "(", "(", "flags", "&", "mask", ")", "!=", "0", ")", "{", "no_str", "=", "\"no-\"", ";", "len", "+=", "strlen", "(", "\"no-\"", ")", ";", "}", "flags", "|=", "mask", ";", "}", "cur_column", "+=", "len", ";", "if", "(", "cur_column", ">", "max_column", ")", "{", "fprintf", "(", "stderr", ",", "\", \\\\\\n%*s\"", ",", "(", "int", ")", "start_column", ",", "\"\"", ")", ";", "cur_column", "=", "start_column", "+", "len", ";", "comma", "=", "\"\"", ";", "}", "fprintf", "(", "file", ",", "\"%s%s%s%s\"", ",", "comma", ",", "prefix", ",", "no_str", ",", "name", ")", ";", "comma", "=", "\", \"", ";", "comma_len", "=", "strlen", "(", "\", \"", ")", ";", "}", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "print", "the", "current", "isa", "or", "misc", "options", "on", "a", "line", "." ]

[ "rs6000", "0", "120", "0", "\"\"", "\"%*s\"", "\"\"", "\"<none>\"", "0", "\"\"", "0", "\"no-\"", "\"no-\"", "0", "\"no-\"", "\"no-\"", "\", \\\\\\n%*s\"", "\"\"", "\"\"", "\"%s%s%s%s\"", "\", \"", "\", \"", "\"\\n\"" ]

[]

[ "<s>", "void", "emitAssignment", "(", "MCSymbol", "*", "S", ",", "const", "MCExpr", "*", "Value", ")", "override", "{", "auto", "*", "Symbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "S", ")", ";", "if", "(", "copyLocalEntry", "(", "Symbol", ",", "Value", ")", ")", "UpdateOther", ".", "insert", "(", "Symbol", ")", ";", "else", "UpdateOther", ".", "erase", "(", "Symbol", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assignment", "of", "Value", "to", "Symbol", "." ]

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "MBlazeMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getMBlazeRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "return", "0", ";", "else", "{", "errs", "(", ")", "<<", "MO", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "0", "0", "0" ]

[]

[ "<s>", "bool", "call_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "call_address_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Call", "insn", "on", "SPARC", "can", "take", "a", "PC-relative", "constant", "address", ",", "or", "any", "regular", "memory", "address", "." ]

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

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFNegFree", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", ";", "return", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "f64", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fneg", "operation", "is", "free", "to", "the", "point", "where", "it", "is", "never", "worthwhile", "to", "replace", "it", "with", "a", "bitwise", "operation", "." ]

[ "AMDGPU", "AMDGPU", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "static", "void", "ia64_output_function_epilogue", "(", "FILE", "*", ")", "{", "int", "i", ";", "if", "(", "current_frame_info", ".", "r", "[", "reg_fp", "]", ")", "{", "const", "char", "*", "tmp", "=", "reg_names", "[", "HARD_FRAME_POINTER_REGNUM", "]", ";", "reg_names", "[", "HARD_FRAME_POINTER_REGNUM", "]", "=", "reg_names", "[", "current_frame_info", ".", "r", "[", "reg_fp", "]", "]", ";", "reg_names", "[", "current_frame_info", ".", "r", "[", "reg_fp", "]", "]", "=", "tmp", ";", "reg_emitted", "(", "reg_fp", ")", ";", "}", "if", "(", "!", "TARGET_REG_NAMES", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "current_frame_info", ".", "n_input_regs", ";", "i", "++", ")", "reg_names", "[", "IN_REG", "(", "i", ")", "]", "=", "ia64_input_reg_names", "[", "i", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "current_frame_info", ".", "n_local_regs", ";", "i", "++", ")", "reg_names", "[", "LOC_REG", "(", "i", ")", "]", "=", "ia64_local_reg_names", "[", "i", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "current_frame_info", ".", "n_output_regs", ";", "i", "++", ")", "reg_names", "[", "OUT_REG", "(", "i", ")", "]", "=", "ia64_output_reg_names", "[", "i", "]", ";", "}", "current_frame_info", ".", "initialized", "=", "0", ";", "}", "</s>" ]

[ "Emit", "the", "function", "epilogue", "." ]

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

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsConstReadLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "MIs", ")", "const", "{", "std", "::", "vector", "<", "unsigned", ">", "Consts", ";", "SmallSet", "<", "int64_t", ",", "4", ">", "Literals", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MIs", ".", "size", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MIs", "[", "i", "]", ";", "if", "(", "!", "isALUInstr", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "ArrayRef", "<", "std", "::", "pair", "<", "MachineOperand", "*", ",", "int64_t", ">>", "Srcs", "=", "getSrcs", "(", "MI", ")", ";", "for", "(", "const", "auto", "&", "Src", ":", "Srcs", ")", "{", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_LITERAL_X", ")", "Literals", ".", "insert", "(", "Src", ".", "second", ")", ";", "if", "(", "Literals", ".", "size", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_CONST", ")", "Consts", ".", "push_back", "(", "Src", ".", "second", ")", ";", "if", "(", "AMDGPU", "::", "R600_KC0RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "R600_KC1RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ")", "{", "unsigned", "Index", "=", "RI", ".", "getEncodingValue", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "&", "0xff", ";", "unsigned", "Chan", "=", "RI", ".", "getHWRegChan", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ";", "Consts", ".", "push_back", "(", "(", "Index", "<<", "2", ")", "|", "Chan", ")", ";", "}", "}", "}", "return", "fitsConstReadLimitations", "(", "Consts", ")", ";", "}", "</s>" ]

[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]

[ "AMDGPU", "R600", "4", "0", "AMDGPU::ALU_LITERAL_X", "4", "AMDGPU::ALU_CONST", "AMDGPU::R600_KC0RegClass", "AMDGPU::R600_KC1RegClass", "0xff", "2" ]

[]

[ "<s>", "static", "void", "flow_dependent_p_1", "(", "rtx", "x", ",", "rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "pinsn", "=", "(", "rtx", "*", ")", "data", ";", "if", "(", "*", "pinsn", "&&", "reg_referenced_p", "(", "x", ",", "*", "pinsn", ")", ")", "*", "pinsn", "=", "NULL_RTX", ";", "}", "</s>" ]

[ "A", "helper", "function", "for", "flow_dependent_p", "called", "through", "note_stores", "." ]

[ "sh" ]

[]

[ "<s>", "aarch64_feature_flags", "get_flags_off", "(", "aarch64_feature_flags", "mask", ")", "{", "return", "(", "0", "|", "(", "feature_deps", "::", "IDENT", "(", ")", ".", "enable", "&", "mask", "?", "AARCH64_FL_", "##", "IDENT", ":", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "set", "of", "all", "features", "that", "would", "need", "to", "be", "disabled", "if", "the", "features", "in", "MASK", "are", "disabled", ".", "Note", "that", "the", "size", "of", "the", "expression", "varies", "linearly", "with", "the", "number", "of", "features", ",", "which", "means", "that", "invoking", "this", "function", "once", "per", "feature", "is", "quadratic", "in", "the", "number", "of", "features", ".", "However", ",", "collecting", "the", "same", "information", "at", "compiler", "start-up", "is", "likely", "to", "be", "quadratic", "too", ",", "so", "we", "'re", "better", "off", "paying", "the", "cost", "once", "per", "compiler", "build", "rather", "than", "once", "per", "compiler", "run", "." ]

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

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isAlwaysUniform", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_readfirstlane", ":", "case", "Intrinsic", "::", "amdgcn_readlane", ":", "case", "Intrinsic", "::", "amdgcn_icmp", ":", "case", "Intrinsic", "::", "amdgcn_fcmp", ":", "case", "Intrinsic", "::", "amdgcn_if_break", ":", "return", "true", ";", "}", "}", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ")", ";", "return", "false", ";", "}", "const", "ExtractValueInst", "*", "ExtValue", "=", "dyn_cast", "<", "ExtractValueInst", ">", "(", "V", ")", ";", "if", "(", "!", "ExtValue", ")", "return", "false", ";", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "ExtValue", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "CI", ")", "return", "false", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "CI", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_if", ":", "case", "Intrinsic", "::", "amdgcn_else", ":", "{", "ArrayRef", "<", "unsigned", ">", "Indices", "=", "ExtValue", "->", "getIndices", "(", ")", ";", "return", "Indices", ".", "size", "(", ")", "==", "1", "&&", "Indices", "[", "0", "]", "==", "1", ";", "}", "}", "}", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ",", "ExtValue", "->", "getIndices", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "Intrinsic::amdgcn_readfirstlane", "Intrinsic::amdgcn_readlane", "Intrinsic::amdgcn_icmp", "Intrinsic::amdgcn_fcmp", "Intrinsic::amdgcn_if_break", "0", "Intrinsic::amdgcn_if", "Intrinsic::amdgcn_else", "1", "0", "1" ]

[]

[ "<s>", "int", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Intrinsic::ID" ]

[]

[ "<s>", "bool", "SPUTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "isInt", "<", "14", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "true", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0", "0", "0", "0", "14", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", "||", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewOp0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_W_X_RV64", ",", "DL", ",", "MVT", "::", "f32", ",", "NewOp0", ")", ";", "return", "FPConv", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::GlobalTLSAddress", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::BITCAST", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i64", "RISCVISD::FMV_W_X_RV64", "MVT::f32", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN" ]

[]

[ "<s>", "int", "getSEHRegNum", "(", "unsigned", "i", ")", "const", "{", "return", "getEncodingValue", "(", "i", ")", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "SEH", "register", "number", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "static", "LoadStoreMethod", "PossibleClasses", "[", "]", "=", "{", "{", "&", "AArch64", "::", "GPR64RegClass", ",", "AArch64", "::", "LSPair64_STR", ",", "AArch64", "::", "LS64_STR", "}", ",", "{", "&", "AArch64", "::", "FPR64RegClass", ",", "AArch64", "::", "LSFPPair64_STR", ",", "AArch64", "::", "LSFP64_STR", "}", ",", "}", ";", "unsigned", "NumClasses", "=", "llvm", "::", "array_lengthof", "(", "PossibleClasses", ")", ";", "emitFrameMemOps", "(", "true", ",", "MBB", ",", "MBBI", ",", "CSI", ",", "TRI", ",", "PossibleClasses", ",", "NumClasses", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LSPair64_STR", "AArch64::LS64_STR", "AArch64::FPR64RegClass", "AArch64::LSFPPair64_STR", "AArch64::LSFP64_STR" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsV3EHReturn", "[", "]", "=", "{", "Hexagon", "::", "R0", ",", "Hexagon", "::", "R1", ",", "Hexagon", "::", "R2", ",", "Hexagon", "::", "R3", ",", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "bool", "HasEHReturn", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "switch", "(", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "Hexagon", "::", "ArchEnum", "::", "V4", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V5", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V55", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V60", ":", "case", "Hexagon", "::", "ArchEnum", "::", "V62", ":", "return", "HasEHReturn", "?", "CalleeSavedRegsV3EHReturn", ":", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R0", "Hexagon::R1", "Hexagon::R2", "Hexagon::R3", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "Hexagon::ArchEnum", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "0" ]

[]

[ "<s>", "int", "legitimate_constant_p", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "vax", "1" ]

[]

[ "<s>", "unsigned", "DCPU16InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "DCPU16", "::", "MOV16mr", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "DCPU16::MOV16mr", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "bool", "cr16_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ";", "}", "</s>" ]

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

[ "cr16" ]

[]

[ "<s>", "const", "RegisterBank", "&", "X86RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "X86", "::", "GR8RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "LOW32_ADDR_ACCESSRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "LOW32_ADDR_ACCESS_RBPRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "X86", "::", "GPRRegBankID", ")", ";", "if", "(", "X86", "::", "FR32XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "FR64XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR128XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR256XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR512RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "X86", "::", "VECRRegBankID", ")", ";", "llvm_unreachable", "(", "\"Unsupported register kind yet.\"", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::GR8RegClass", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "X86::LOW32_ADDR_ACCESSRegClass", "X86::LOW32_ADDR_ACCESS_RBPRegClass", "X86::GPRRegBankID", "X86::FR32XRegClass", "X86::FR64XRegClass", "X86::VR128XRegClass", "X86::VR256XRegClass", "X86::VR512RegClass", "X86::VECRRegBankID", "\"Unsupported register kind yet.\"" ]

[]

[ "<s>", "bool", "GBZ80InstrInfo", "::", "isConditionalBranch", "(", "const", "MachineInstr", "&", "I", ")", "const", "{", "return", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JP_cc_nn", "||", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JR_cc_e", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "may", "fall", "through", "to", "the", "next", "instruction", "or", "may", "transfer", "control", "flow", "to", "some", "other", "block", "." ]

[ "GBZ80", "GB", "GB::JP_cc_nn", "GB::JR_cc_e" ]

[]

[ "<s>", "void", "dimode_scalar_chain", "::", "mark_dual_mode_def", "(", "df_ref", "def", ")", "{", "gcc_assert", "(", "DF_REF_REG_DEF_P", "(", "def", ")", ")", ";", "if", "(", "bitmap_bit_p", "(", "defs_conv", ",", "DF_REF_REGNO", "(", "def", ")", ")", ")", "return", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Mark r%d def in insn %d as requiring both modes in chain #%d\\n\"", ",", "DF_REF_REGNO", "(", "def", ")", ",", "DF_REF_INSN_UID", "(", "def", ")", ",", "chain_id", ")", ";", "bitmap_set_bit", "(", "defs_conv", ",", "DF_REF_REGNO", "(", "def", ")", ")", ";", "}", "</s>" ]

[ "For", "DImode", "conversion", ",", "mark", "register", "defined", "by", "DEF", "as", "requiring", "conversion", "." ]

[ "i386", "\" Mark r%d def in insn %d as requiring both modes in chain #%d\\n\"" ]

[]

[ "<s>", "bool", "PPCLoopPreIncPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "avr_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "func", "ATTRIBUTE_UNUSED", ")", "{", "int", "offs", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offs", "<=", "4", ")", "offs", "=", "(", "offs", "+", "1", ")", "&", "~", "1", ";", "return", "gen_rtx_REG", "(", "mode", ",", "avr_ret_register", "(", ")", "+", "2", "-", "offs", ")", ";", "}", "</s>" ]

[ "Ceate", "an", "RTX", "representing", "the", "place", "where", "a", "library", "function", "returns", "a", "value", "of", "mode", "MODE", "." ]

[ "avr", "4", "1", "1", "2" ]

[]

[ "<s>", "bool", "TPCPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisablePacketizer", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "TPCPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "if", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "->", "getInstrItins", "(", ")", "->", "isEmpty", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "TPC", "::", "IMPLICIT_DEF", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "Packetizer", ".", "PacketNum", "=", "0", ";", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "MB", ".", "begin", "(", ")", ",", "MB", ".", "end", "(", ")", ")", ";", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC", "TPC", "\"Empty DFA table!\"", "TPC::IMPLICIT_DEF", "0" ]

[]