Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "rvexTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "PerformDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "rvex", "rvex", "ISD::SDIVREM", "ISD::UDIVREM" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARCompact Assembly Printer\"", ";", "}", "</s>" ]

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

[ "ARCompact", "\"ARCompact Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "getBaseReg", "(", ")", "{", "return", "BaseReg", ";", "}", "</s>" ]

[ "Get", "the", "base", "register", "of", "the", "pointer", "value", "." ]

[ "X86" ]

[]

[ "<s>", "static", "bool", "check_required_extensions", "(", "location_t", "location", ",", "tree", "fndecl", ",", "aarch64_feature_flags", "required_extensions", ")", "{", "auto", "missing_extensions", "=", "required_extensions", "&", "~", "aarch64_asm_isa_flags", ";", "if", "(", "missing_extensions", "==", "0", ")", "return", "check_required_registers", "(", "location", ",", "fndecl", ")", ";", "static", "const", "struct", "{", "aarch64_feature_flags", "flag", ";", "const", "char", "*", "name", ";", "}", "extensions", "[", "]", "=", "{", "{", "AARCH64_FL_", "##", "IDENT", ",", "EXT_NAME", "}", ",", "}", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "extensions", ")", ";", "++", "i", ")", "if", "(", "missing_extensions", "&", "extensions", "[", "i", "]", ".", "flag", ")", "{", "report_missing_extension", "(", "location", ",", "fndecl", ",", "extensions", "[", "i", "]", ".", "name", ")", ";", "return", "false", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Check", "whether", "all", "the", "RVV_REQUIRE_", "*", "values", "in", "REQUIRED_EXTENSIONS", "are", "enabled", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mips Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Machine Code Emitter\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "HTM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "SHUXIRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Instruction not supported\"", ")", ";", "case", "SHUXI", "::", "LD", ":", "case", "SHUXI", "::", "ST", ":", "case", "SHUXI", "::", "ADDri", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "%", "4", ")", "{", "llvm_unreachable", "(", "\"Offset must be aligned to 4 bytes because memory is \"", "\"32-bit word addressable only\"", ")", ";", "}", "FIOp", ".", "ChangeToRegister", "(", "SHUXI", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "0", "\"Instruction not supported\"", "SHUXI::LD", "SHUXI::ST", "SHUXI::ADDri", "1", "4", "\"Offset must be aligned to 4 bytes because memory is \"", "\"32-bit word addressable only\"", "SHUXI::SP" ]

[]

[ "<s>", "unsigned", "X86FrameLowering", "::", "getWinEHParentFrameOffset", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "unsigned", "Offset", "=", "16", ";", "Offset", "+=", "SlotSize", ";", "Offset", "+=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getCalleeSavedFrameSize", "(", ")", ";", "Offset", "+=", "getWinEHFuncletFrameSize", "(", "MF", ")", ";", "return", "Offset", ";", "}", "</s>" ]

[ "The", "parent", "frame", "offset", "(", "aka", "dispFrame", ")", "is", "only", "used", "on", "X86_64", "to", "retrieve", "the", "parent", "'s", "frame", "pointer", "." ]

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

[]

[ "<s>", "void", "gas_output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "str", ",", "size_t", "length", ")", "{", "const", "unsigned", "char", "*", "_ascii_bytes", "=", "(", "const", "unsigned", "char", "*", ")", "str", ";", "const", "unsigned", "char", "*", "limit", "=", "_ascii_bytes", "+", "length", ";", "unsigned", "bytes_in_chunk", "=", "0", ";", "for", "(", ";", "_ascii_bytes", "<", "limit", ";", "_ascii_bytes", "++", ")", "{", "const", "unsigned", "char", "*", "p", ";", "if", "(", "bytes_in_chunk", ">=", "60", ")", "{", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "bytes_in_chunk", "=", "0", ";", "}", "for", "(", "p", "=", "_ascii_bytes", ";", "p", "<", "limit", "&&", "*", "p", "!=", "'\\0'", ";", "p", "++", ")", "continue", ";", "if", "(", "p", "<", "limit", "&&", "(", "p", "-", "_ascii_bytes", ")", "<=", "(", "signed", ")", "STRING_LIMIT", ")", "{", "if", "(", "bytes_in_chunk", ">", "0", ")", "{", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "bytes_in_chunk", "=", "0", ";", "}", "gas_output_limited_string", "(", "file", ",", "(", "char", "*", ")", "_ascii_bytes", ")", ";", "_ascii_bytes", "=", "p", ";", "}", "else", "{", "int", "escape", ";", "unsigned", "ch", ";", "if", "(", "bytes_in_chunk", "==", "0", ")", "fprintf", "(", "file", ",", "\"\\t.ascii\\t\\\"\"", ")", ";", "switch", "(", "escape", "=", "ESCAPES", "[", "ch", "=", "*", "_ascii_bytes", "]", ")", "{", "case", "0", ":", "putc", "(", "ch", ",", "file", ")", ";", "bytes_in_chunk", "++", ";", "break", ";", "case", "1", ":", "fprintf", "(", "file", ",", "\"\\\\%03o\"", ",", "ch", ")", ";", "bytes_in_chunk", "+=", "4", ";", "break", ";", "default", ":", "putc", "(", "'\\\\'", ",", "file", ")", ";", "putc", "(", "escape", ",", "file", ")", ";", "bytes_in_chunk", "+=", "2", ";", "break", ";", "}", "}", "}", "if", "(", "bytes_in_chunk", ">", "0", ")", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "}", "</s>" ]

[ "The", "routine", "used", "to", "output", "sequences", "of", "byte", "values", ".", "We", "use", "a", "special", "version", "of", "this", "for", "most", "svr4", "targets", "because", "doing", "so", "makes", "the", "generated", "assembly", "code", "more", "compact", "(", "and", "thus", "faster", "to", "assemble", ")", "as", "well", "as", "more", "readable", ".", "Note", "that", "if", "we", "find", "subparts", "of", "the", "character", "sequence", "which", "end", "with", "NUL", "(", "and", "which", "are", "shorter", "than", "STRING_LIMIT", ")", "we", "output", "those", "using", "ASM_OUTPUT_LIMITED_STRING", "." ]

[ "avr", "0", "60", "\"\\\"\\n\"", "0", "0", "\"\\\"\\n\"", "0", "0", "\"\\t.ascii\\t\\\"\"", "0", "1", "\"\\\\%03o\"", "4", "2", "0", "\"\\\"\\n\"" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "PerformATOMIC_FENCECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "return", "PerformATOMIC_STORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "PerformSRACombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "AArch64", "AArch64", "ISD::AND", "ISD::ATOMIC_FENCE", "ISD::ATOMIC_STORE", "ISD::OR", "ISD::SRA" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAMDGPUPrintfRuntimeBinding", "(", ")", ")", ";", "addPass", "(", "createAMDGPUCtorDtorLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUFixFunctionBitcastsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPropagateAttributesEarlyPass", "(", "&", "TM", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "EnableLowerModuleLDS", ")", "{", "if", "(", "EnableLDSReplaceWithPointer", ")", "addPass", "(", "createAMDGPUReplaceLDSUseWithPointerPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerModuleLDSPass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "if", "(", "isPassEnabled", "(", "EnableScalarIRPasses", ")", ")", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "isPassEnabled", "(", "EnableScalarIRPasses", ")", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "static", "int", "ix86_mode_needed", "(", "int", "entity", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_needed", "(", "insn", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_needed", "(", "insn", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "ix86_i387_mode_needed", "(", "entity", ",", "insn", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "createAMDGPULateCodeGenPreparePass", "(", ")", ")", ";", "if", "(", "EnableAtomicOptimizations", ")", "{", "addPass", "(", "createAMDGPUAtomicOptimizerPass", "(", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "if", "(", "EnableStructurizerWorkarounds", ")", "{", "addPass", "(", "createFixIrreduciblePass", "(", ")", ")", ";", "addPass", "(", "createUnifyLoopExitsPass", "(", ")", ")", ";", "}", "addPass", "(", "createStructurizeCFGPass", "(", "false", ")", ")", ";", "}", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "addPass", "(", "createLCSSAPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_expand_fp_absneg_operator", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "mask", ",", "set", ",", "use", ",", "clob", ",", "dst", ",", "src", ";", "bool", "matching_memory", ";", "bool", "use_sse", "=", "false", ";", "bool", "vector_mode", "=", "VECTOR_MODE_P", "(", "mode", ")", ";", "enum", "machine_mode", "elt_mode", "=", "mode", ";", "if", "(", "vector_mode", ")", "{", "elt_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "use_sse", "=", "true", ";", "}", "else", "if", "(", "TARGET_SSE_MATH", ")", "use_sse", "=", "SSE_FLOAT_MODE_P", "(", "mode", ")", ";", "if", "(", "use_sse", ")", "mask", "=", "ix86_build_signbit_mask", "(", "elt_mode", ",", "vector_mode", ",", "code", "==", "ABS", ")", ";", "else", "{", "mask", "=", "const0_rtx", ";", "}", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "matching_memory", "=", "false", ";", "if", "(", "MEM_P", "(", "dst", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "dst", ",", "src", ")", ")", "matching_memory", "=", "true", ";", "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "!", "matching_memory", ")", "src", "=", "force_reg", "(", "mode", ",", "src", ")", ";", "if", "(", "vector_mode", ")", "{", "set", "=", "gen_rtx_fmt_ee", "(", "code", "==", "NEG", "?", "XOR", ":", "AND", ",", "mode", ",", "src", ",", "mask", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "set", ")", ";", "emit_insn", "(", "set", ")", ";", "}", "else", "{", "set", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "set", ")", ";", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "mask", ")", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "3", ",", "set", ",", "use", ",", "clob", ")", ")", ")", ";", "}", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "floating", "point", "ABS", "or", "NEG", "." ]

[ "i386", "0", "1", "3", "0", "0" ]

[]

[ "<s>", "static", "machine_mode", "mips_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "if", "(", "TARGET_PAIRED_SINGLE_FLOAT", "&&", "mode", "==", "SFmode", ")", "return", "V2SFmode", ";", "if", "(", "!", "ISA_HAS_MSA", ")", "return", "word_mode", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "return", "V16QImode", ";", "case", "E_HImode", ":", "return", "V8HImode", ";", "case", "E_SImode", ":", "return", "V4SImode", ";", "case", "E_DImode", ":", "return", "V2DImode", ";", "case", "E_SFmode", ":", "return", "V4SFmode", ";", "case", "E_DFmode", ":", "return", "V2DFmode", ";", "default", ":", "break", ";", "}", "return", "word_mode", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "pru_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.4byte\\t%pmem(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "size", "==", "INIT_ARRAY_ENTRY_BYTES", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.2byte\\t%pmem(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "{", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_INTEGER", "'", ".", "Target", "hook", "for", "assembling", "integer", "objects", ".", "PRU", "version", "needs", "special", "handling", "for", "references", "to", "pmem", ".", "Code", "copied", "from", "AVR", "." ]

[ "pru", "\"\\t.4byte\\t%pmem(\"", "\")\\n\"", "\"\\t.2byte\\t%pmem(\"", "\")\\n\"" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", ",", "Regs", ")", ";", "}", ")", ")", "return", "false", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "CC_X86", ",", "DL", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "0", "X86" ]

[]

[ "<s>", "Instruction", "*", "RISCVTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "Inst", ")", "&&", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "Builder", ".", "CreateFence", "(", "Ord", ")", ";", "if", "(", "isa", "<", "StoreInst", ">", "(", "Inst", ")", "&&", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "Release", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "void", "alpha_expand_builtin_establish_vms_condition_handler", "(", "rtx", "target", ",", "rtx", "handler", ")", "{", "rtx", "handler_slot_address", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "VMS_COND_HANDLER_FP_OFFSET", ")", ";", "rtx", "handler_slot", "=", "gen_rtx_MEM", "(", "DImode", ",", "handler_slot_address", ")", ";", "emit_move_insn", "(", "target", ",", "handler_slot", ")", ";", "emit_move_insn", "(", "handler_slot", ",", "handler", ")", ";", "cfun", "->", "machine", "->", "uses_condition_handler", "=", "true", ";", "}", "</s>" ]

[ "Expand", "code", "to", "store", "the", "currently", "installed", "user", "VMS", "condition", "handler", "into", "TARGET", "and", "install", "HANDLER", "as", "the", "new", "condition", "handler", "." ]

[ "alpha" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", "->", "print", "(", "errs", "(", ")", ",", "&", "DAG", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "LowerFP_TO_FP16", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ_CTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_FP16", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "static", "const", "char", "*", "section_for_sym", "(", "rtx", "sym", ")", "{", "nvptx_data_area", "area", "=", "SYMBOL_DATA_AREA", "(", "sym", ")", ";", "static", "char", "const", "*", "const", "areas", "[", "]", "=", "{", "\"\"", ",", "\".global\"", ",", "\".shared\"", ",", "\".local\"", ",", "\".const\"", ",", "\".param\"", "}", ";", "return", "areas", "[", "area", "]", ";", "}", "</s>" ]

[ "Return", "the", "PTX", "name", "of", "the", "data", "area", "in", "which", "SYM", "should", "be", "placed", ".", "The", "symbol", "must", "have", "already", "been", "processed", "by", "nvptx_encode_seciton_info", ",", "or", "equivalent", "." ]

[ "nvptx", "\"\"", "\".global\"", "\".shared\"", "\".local\"", "\".const\"", "\".param\"" ]

[]

[ "<s>", "void", "BPFPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createBPFAbstractMemberAccess", "(", "&", "getBPFTargetMachine", "(", ")", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

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

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

[ "SIC", "SIC" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "unsigned", "TyAlign", "=", "TD", "->", "getABITypeAlignment", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "8", ")", "return", "TyAlign", ";", "return", "8", ";", "}", "unsigned", "Align", "=", "4", ";", "if", "(", "Subtarget", "->", "hasXMM", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ")", ";", "return", "Align", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "X86", "X86", "8", "8", "4" ]

[]

[ "<s>", "bool", "HexagonSplitDoubleRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Splitting double registers in function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "UUSetMap", "P2Rs", ";", "LoopRegMap", "IRM", ";", "collectIndRegs", "(", "IRM", ")", ";", "partitionRegisters", "(", "P2Rs", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Register partitioning: (partition #0 is fixed)\\n\"", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "dbgs", "(", ")", "<<", "'#'", "<<", "I", "->", "first", "<<", "\" -> \"", ";", "dump_partition", "(", "dbgs", "(", ")", ",", "I", "->", "second", ",", "*", "TRI", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "}", ")", ";", "bool", "Changed", "=", "false", ";", "int", "Limit", "=", "MaxHSDR", ";", "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "first", "==", "0", ")", "continue", ";", "if", "(", "Limit", ">=", "0", "&&", "Counter", ">=", "Limit", ")", "break", ";", "USet", "&", "Part", "=", "I", "->", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Calculating profit for partition #\"", "<<", "I", "->", "first", "<<", "'\\n'", ")", ";", "if", "(", "!", "isProfitable", "(", "Part", ",", "IRM", ")", ")", "continue", ";", "Counter", "++", ";", "Changed", "|=", "splitPartition", "(", "Part", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Splitting double registers in function: \"", "Hexagon", "\"Register partitioning: (partition #0 is fixed)\\n\"", "\" -> \"", "0", "0", "\"Calculating profit for partition #\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "8", "RISCV", "0" ]

[]

[ "<s>", "static", "tree", "ix86_veclibabi_acml", "(", "enum", "built_in_function", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "20", "]", "=", "\"__vr.._\"", ";", "tree", "fntype", ",", "new_fndecl", ",", "args", ";", "unsigned", "arity", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "TARGET_64BIT", "||", "!", "flag_unsafe_math_optimizations", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "case", "BUILT_IN_SIN", ":", "case", "BUILT_IN_COS", ":", "case", "BUILT_IN_EXP", ":", "case", "BUILT_IN_LOG", ":", "case", "BUILT_IN_LOG2", ":", "case", "BUILT_IN_LOG10", ":", "name", "[", "4", "]", "=", "'d'", ";", "name", "[", "5", "]", "=", "'2'", ";", "if", "(", "el_mode", "!=", "DFmode", "||", "n", "!=", "2", ")", "return", "NULL_TREE", ";", "break", ";", "case", "BUILT_IN_SINF", ":", "case", "BUILT_IN_COSF", ":", "case", "BUILT_IN_EXPF", ":", "case", "BUILT_IN_POWF", ":", "case", "BUILT_IN_LOGF", ":", "case", "BUILT_IN_LOG2F", ":", "case", "BUILT_IN_LOG10F", ":", "name", "[", "4", "]", "=", "'s'", ";", "name", "[", "5", "]", "=", "'4'", ";", "if", "(", "el_mode", "!=", "SFmode", "||", "n", "!=", "4", ")", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "builtin_decl_implicit", "(", "fn", ")", ")", ")", ";", "sprintf", "(", "name", "+", "7", ",", "\"%s\"", ",", "bname", "+", "10", ")", ";", "arity", "=", "0", ";", "for", "(", "args", "=", "DECL_ARGUMENTS", "(", "builtin_decl_implicit", "(", "fn", ")", ")", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "arity", "++", ";", "if", "(", "arity", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

[ "Handler", "for", "an", "ACML-style", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "i386", "20", "\"__vr.._\"", "4", "5", "2", "4", "5", "4", "7", "\"%s\"", "10", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "aarch64_expand_builtin_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", ";", "tree", "f_stack", ",", "f_grtop", ",", "f_vrtop", ",", "f_groff", ",", "f_vroff", ";", "tree", "stack", ",", "grtop", ",", "vrtop", ",", "groff", ",", "vroff", ";", "tree", "t", ";", "int", "gr_save_area_size", ";", "int", "vr_save_area_size", ";", "int", "vr_offset", ";", "cum", "=", "&", "crtl", "->", "args", ".", "info", ";", "gr_save_area_size", "=", "(", "NUM_ARG_REGS", "-", "cum", "->", "aapcs_ncrn", ")", "*", "UNITS_PER_WORD", ";", "vr_save_area_size", "=", "(", "NUM_FP_ARG_REGS", "-", "cum", "->", "aapcs_nvrn", ")", "*", "UNITS_PER_VREG", ";", "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "cum", "->", "aapcs_nvrn", "==", "0", ")", ";", "vr_save_area_size", "=", "0", ";", "}", "f_stack", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_grtop", "=", "DECL_CHAIN", "(", "f_stack", ")", ";", "f_vrtop", "=", "DECL_CHAIN", "(", "f_grtop", ")", ";", "f_groff", "=", "DECL_CHAIN", "(", "f_vrtop", ")", ";", "f_vroff", "=", "DECL_CHAIN", "(", "f_groff", ")", ";", "stack", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_stack", ")", ",", "valist", ",", "f_stack", ",", "NULL_TREE", ")", ";", "grtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_grtop", ")", ",", "valist", ",", "f_grtop", ",", "NULL_TREE", ")", ";", "vrtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vrtop", ")", ",", "valist", ",", "f_vrtop", ",", "NULL_TREE", ")", ";", "groff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_groff", ")", ",", "valist", ",", "f_groff", ",", "NULL_TREE", ")", ";", "vroff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vroff", ")", ",", "valist", ",", "f_vroff", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "stack", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "cum", "->", "aapcs_stack_size", ">", "0", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "cum", "->", "aapcs_stack_size", "*", "UNITS_PER_WORD", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "stack", ")", ",", "stack", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "grtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "grtop", ")", ",", "grtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "vrtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "vr_offset", "=", "ROUND_UP", "(", "gr_save_area_size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "vr_offset", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "vr_offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vrtop", ")", ",", "vrtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "groff", ")", ",", "groff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "groff", ")", ",", "-", "gr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vroff", ")", ",", "vroff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "vroff", ")", ",", "-", "vr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN_VA_START", "." ]

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

[]

[ "<s>", "void", "LanaiInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "unsigned", "SourceRegister", ",", "bool", "IsKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RegisterClass", ",", "const", "TargetRegisterInfo", "*", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "Position", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "Position", "->", "getDebugLoc", "(", ")", ";", "}", "if", "(", "!", "Lanai", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RegisterClass", ")", ")", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "Position", ",", "DL", ",", "get", "(", "Lanai", "::", "SW_RI", ")", ")", ".", "addReg", "(", "SourceRegister", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "LPAC", "::", "ADD", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::GPRRegClass", "\"Can't store this register to stack slot\"", "Lanai::SW_RI", "0" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "4095", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "ExtraCode", ")", "ExtraCode", "=", "\"\"", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'w'", ":", "if", "(", "!", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR32RegClass", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'x'", ":", "if", "(", "!", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR64RegClass", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'H'", ":", "case", "'Q'", ":", "case", "'R'", ":", "llvm_unreachable", "(", "\"FIXME: Unimplemented register pairs\"", ")", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "if", "(", "!", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'A'", ":", "if", "(", "!", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "false", ",", "\"\"", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'L'", ":", "if", "(", "!", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"lo12\"", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'G'", ":", "if", "(", "!", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"hi12\"", ",", "O", ")", ")", "return", "false", ";", "break", ";", "case", "'a'", ":", "return", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand for inline assembly\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "printModifiedFPRAsmOperand", "(", "MO", ",", "TRI", ",", "'v'", ",", "O", ")", ")", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "'#'", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "assert", "(", "MO", ".", "getFPImm", "(", ")", "->", "isExactlyValue", "(", "0.0", ")", "&&", "\"Only FP 0.0 expected\"", ")", ";", "O", "<<", "\"#0.0\"", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "return", "printSymbolicAddress", "(", "MO", ",", "false", ",", "\"\"", ",", "O", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\"", "0", "AArch64::GPR32RegClass", "AArch64::GPR64RegClass", "\"FIXME: Unimplemented register pairs\"", "0", "\"\"", "\"lo12\"", "\"hi12\"", "\"Unexpected operand for inline assembly\"", "AArch64", "0.0", "\"Only FP 0.0 expected\"", "\"#0.0\"", "\"\"" ]

[]

[ "<s>", "Nios2ExprKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "Nios2", "Nios2" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPostRewrite", "(", ")", "{", "addPass", "(", "createSystemZPostRewritePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Add", "passes", "to", "be", "run", "immediately", "after", "virtual", "registers", "are", "rewritten", "to", "physical", "registers", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Hardware Loops\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Hardware Loops\"" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "FoldImmediate", "(", "MachineInstr", "&", "UseMI", ",", "MachineInstr", "&", "DefMI", ",", "unsigned", "Reg", ",", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "unsigned", "DefOpc", "=", "DefMI", ".", "getOpcode", "(", ")", ";", "if", "(", "DefOpc", "!=", "SystemZ", "::", "LHIMux", "&&", "DefOpc", "!=", "SystemZ", "::", "LHI", "&&", "DefOpc", "!=", "SystemZ", "::", "LGHI", ")", "return", "false", ";", "if", "(", "DefMI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "!=", "Reg", ")", "return", "false", ";", "int32_t", "ImmVal", "=", "(", "int32_t", ")", "DefMI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "UseOpc", "=", "UseMI", ".", "getOpcode", "(", ")", ";", "unsigned", "NewUseOpc", ";", "unsigned", "UseIdx", ";", "int", "CommuteIdx", "=", "-", "1", ";", "switch", "(", "UseOpc", ")", "{", "case", "SystemZ", "::", "LOCRMux", ":", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "return", "false", ";", "NewUseOpc", "=", "SystemZ", "::", "LOCHIMux", ";", "if", "(", "UseMI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ";", "else", "if", "(", "UseMI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ",", "CommuteIdx", "=", "1", ";", "else", "return", "false", ";", "break", ";", "case", "SystemZ", "::", "LOCGR", ":", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "return", "false", ";", "NewUseOpc", "=", "SystemZ", "::", "LOCGHI", ";", "if", "(", "UseMI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ";", "else", "if", "(", "UseMI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "UseIdx", "=", "2", ",", "CommuteIdx", "=", "1", ";", "else", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "CommuteIdx", "!=", "-", "1", ")", "if", "(", "!", "commuteInstruction", "(", "UseMI", ",", "false", ",", "CommuteIdx", ",", "UseIdx", ")", ")", "return", "false", ";", "bool", "DeleteDef", "=", "MRI", "->", "hasOneNonDBGUse", "(", "Reg", ")", ";", "UseMI", ".", "setDesc", "(", "get", "(", "NewUseOpc", ")", ")", ";", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ".", "ChangeToImmediate", "(", "ImmVal", ")", ";", "if", "(", "DeleteDef", ")", "DefMI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Reg", "is", "known", "to", "be", "defined", "by", "a", "move", "immediate", "instruction", ",", "try", "to", "fold", "the", "immediate", "into", "the", "use", "instruction", "." ]

[ "SystemZ", "SystemZ", "SystemZ::LHIMux", "SystemZ::LHI", "SystemZ::LGHI", "0", "1", "1", "SystemZ::LOCRMux", "SystemZ::LOCHIMux", "2", "2", "1", "2", "1", "SystemZ::LOCGR", "SystemZ::LOCGHI", "2", "2", "1", "2", "1", "1" ]

[]

[ "<s>", "void", "BPFPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createBPFAbstractMemberAccess", "(", "&", "getBPFTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createBPFPreserveDIType", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "isForcedDPP", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "DPP", ")", ")", "||", "(", "isForcedSDWA", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", ")", ")", "return", "Match_InvalidOperand", ";", "if", "(", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOPAsmPrefer32Bit", ")", "&&", "getForcedEncodingSize", "(", ")", "!=", "64", ")", "return", "Match_PreferE32", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_sdwa_vi", "||", "Inst", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_sdwa_vi", ")", "{", "auto", "OpNum", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Inst", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst_sel", ")", ";", "const", "auto", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "Op", ".", "isImm", "(", ")", "||", "Op", ".", "getImm", "(", ")", "!=", "AMDGPU", "::", "SDWA", "::", "SdwaSel", "::", "DWORD", ")", "{", "return", "Match_InvalidOperand", ";", "}", "}", "return", "Match_Success", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3", "SIInstrFlags::DPP", "SIInstrFlags::SDWA", "SIInstrFlags::VOP3", "SIInstrFlags::VOPAsmPrefer32Bit", "64", "AMDGPU::V_MAC_F32_sdwa_vi", "AMDGPU::V_MAC_F16_sdwa_vi", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::SDWA" ]

[]

[ "<s>", "static", "bool", "mn10300_can_output_mi_thunk", "(", "const_tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "const_tree", "function", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "mn10300_output_mi_thunk", "would", "be", "able", "to", "output", "the", "assembler", "code", "for", "the", "thunk", "function", "specified", "by", "the", "arguments", "it", "is", "passed", ",", "and", "false", "otherwise", "." ]

[ "mn10300" ]

[]

[ "<s>", "void", "MBlazeTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "MCSectionELF", "::", "SHT_NOBITS", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "MBlaze", "MBlaze", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "MachineInstr", "*", "Thumb2InstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "MachineInstr", "*", "RV", "=", "ARMBaseInstrInfo", "::", "optimizeSelect", "(", "MI", ",", "SeenMIs", ",", "PreferFalse", ")", ";", "if", "(", "!", "RV", "&&", "getSubtarget", "(", ")", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "!", "PreferNoCSEL", ")", "{", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "DestReg", ".", "isVirtual", "(", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "t2CSEL", ")", ",", "DestReg", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "return", "NewMI", ";", "}", "return", "RV", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "ARM", "ARM", "0", "ARM::t2CSEL", "2", "1", "3" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "if", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVSX64rr32", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unreachable!\"", ")", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "SubIdx", "=", "X86", "::", "sub_8bit", ";", "break", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "SubIdx", "=", "X86", "::", "sub_16bit", ";", "break", ";", "case", "X86", "::", "MOVSX64rr32", ":", "SubIdx", "=", "X86", "::", "sub_32bit", ";", "break", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVSX64rr32", "0", "1", "1", "0", "\"Unreachable!\"", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::sub_8bit", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::sub_16bit", "X86::MOVSX64rr32", "X86::sub_32bit" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_load_psi_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", "CR_TAB", "\"ld %C0,%1\"", "CR_TAB", "\"ld __tmp_reg__,-%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %A0,%1\"", "CR_TAB", "\"mov %B0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "8", ")", ";", "}", "else", "{", "return", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1+\"", "CR_TAB", "\"ld %C0,%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "reg_dest", "!=", "reg_base", "-", "2", "&&", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "{", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "return", "\"\"", ";", "}", "}", "</s>" ]

[ "Handle", "loads", "of", "24-bit", "types", "from", "memory", "to", "register", "." ]

[ "avr", "0", "1", "0", "2", "\"ld %C0,%1\"", "\"ld __tmp_reg__,-%1\"", "1", "\"ld %A0,%1\"", "\"mov %B0,__tmp_reg__\"", "8", "\"ld %A0,%1+\"", "\"ld %B0,%1+\"", "\"ld %C0,%1\"", "3", "2", "2", "2", "\"\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "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", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Ins", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "enum", "reg_class", "aarch64_regno_regclass", "(", "unsigned", "regno", ")", "{", "if", "(", "STUB_REGNUM_P", "(", "regno", ")", ")", "return", "STUB_REGS", ";", "if", "(", "GP_REGNUM_P", "(", "regno", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "POINTER_REGS", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "return", "(", "FP_LO8_REGNUM_P", "(", "regno", ")", "?", "FP_LO8_REGS", ":", "FP_LO_REGNUM_P", "(", "regno", ")", "?", "FP_LO_REGS", ":", "FP_REGS", ")", ";", "if", "(", "PR_REGNUM_P", "(", "regno", ")", ")", "return", "PR_LO_REGNUM_P", "(", "regno", ")", "?", "PR_LO_REGS", ":", "PR_HI_REGS", ";", "if", "(", "regno", "==", "FFR_REGNUM", "||", "regno", "==", "FFRT_REGNUM", ")", "return", "FFR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "REGNO_REG_CLASS", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "mips_secondary_memory_needed", "(", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ",", "machine_mode", "mode", ")", "{", "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "(", "(", "class1", "==", "FP_REGS", ")", "!=", "(", "class2", "==", "FP_REGS", ")", ")", "&&", "(", "(", "TARGET_FLOATXX", "&&", "!", "ISA_HAS_MXHC1", ")", "||", "TARGET_O32_FP64A_ABI", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">=", "8", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "SECONDARY_MEMORY_NEEDED", "." ]

[ "mips", "8" ]

[]

[ "<s>", "static", "rtx", "safe_vector_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "x", "!=", "const0_rtx", ")", "return", "x", ";", "x", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_iwmmxt_clrdi", "(", "mode", "==", "DImode", "?", "x", ":", "gen_rtx_SUBREG", "(", "DImode", ",", "x", ",", "0", ")", ")", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Errors", "in", "the", "source", "file", "can", "cause", "expand_expr", "to", "return", "const0_rtx", "where", "we", "expect", "a", "vector", ".", "To", "avoid", "crashing", ",", "use", "one", "of", "the", "vector", "clear", "instructions", "." ]

[ "arm", "0" ]

[]

[ "<s>", "unsigned", "AMDGPUInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "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", "." ]

[ "R600", "0" ]

[]

[ "<s>", "static", "void", "pa_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "TARGET_PA_20", ")", "{", "fputs", "(", "\"\\tmfia\t%r20\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t48(%r20),%r22\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tcopy\t%r22,%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbb,>=,n\t%r22,30,.+16\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tdepwi\t0,31,2,%r22\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t0(%r22),%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t4(%r22),%r19\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbve\t\t(%r21)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t52(%r1),%r29\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "}", "else", "{", "if", "(", "ASSEMBLER_DIALECT", "==", "0", ")", "{", "fputs", "(", "\"\\tbl\t.+8,%r20\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tdepi\t0,31,2,%r20\\n\"", ",", "f", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tb,l\t.+8,%r20\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tdepwi\t0,31,2,%r20\\n\"", ",", "f", ")", ";", "}", "fputs", "(", "\"\\tldw\t\t40(%r20),%r22\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tcopy\t%r22,%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbb,>=,n\t%r22,30,.+16\\n\"", ",", "f", ")", ";", "if", "(", "ASSEMBLER_DIALECT", "==", "0", ")", "fputs", "(", "\"\\tdepi\t0,31,2,%r22\\n\"", ",", "f", ")", ";", "else", "fputs", "(", "\"\\tdepwi\t0,31,2,%r22\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t0(%r22),%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t4(%r22),%r19\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldsid\t(%r21),%r1\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tmtsp\t%r1,%sr0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbe\t\t0(%sr0,%r21)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t\t44(%r20),%r29\\n\"", ",", "f", ")", ";", "}", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "}", "else", "{", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tmfia\t%r31\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t24(%r31),%r27\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t32(%r31),%r31\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t16(%r27),%r1\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbve\t(%r1)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t24(%r27),%r27\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0 ; fptr\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0 ; static link\\n\"", ",", "f", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "the", "variable", "parts.\\", "The", "trampoline", "sets", "the", "static", "chain", "pointer", "to", "STATIC_CHAIN_REGNUM", "and", "then", "branches", "to", "the", "specified", "routine", ".", "This", "code", "template", "is", "copied", "from", "text", "segment", "to", "stack", "location", "and", "then", "patched", "with", "pa_trampoline_init", "to", "contain", "valid", "values", ",", "and", "then", "entered", "as", "a", "subroutine", ".", "It", "is", "best", "to", "keep", "this", "as", "small", "as", "possible", "to", "avoid", "having", "to", "flush", "multiple", "lines", "in", "the", "cache", "." ]

[ "pa", "\"\\tmfia\t%r20\\n\"", "\"\\tldw\t\t48(%r20),%r22\\n\"", "\"\\tcopy\t%r22,%r21\\n\"", "\"\\tbb,>=,n\t%r22,30,.+16\\n\"", "\"\\tdepwi\t0,31,2,%r22\\n\"", "\"\\tldw\t\t0(%r22),%r21\\n\"", "\"\\tldw\t\t4(%r22),%r19\\n\"", "\"\\tbve\t\t(%r21)\\n\"", "\"\\tldw\t\t52(%r1),%r29\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "0", "\"\\tbl\t.+8,%r20\\n\"", "\"\\tdepi\t0,31,2,%r20\\n\"", "\"\\tb,l\t.+8,%r20\\n\"", "\"\\tdepwi\t0,31,2,%r20\\n\"", "\"\\tldw\t\t40(%r20),%r22\\n\"", "\"\\tcopy\t%r22,%r21\\n\"", "\"\\tbb,>=,n\t%r22,30,.+16\\n\"", "0", "\"\\tdepi\t0,31,2,%r22\\n\"", "\"\\tdepwi\t0,31,2,%r22\\n\"", "\"\\tldw\t\t0(%r22),%r21\\n\"", "\"\\tldw\t\t4(%r22),%r19\\n\"", "\"\\tldsid\t(%r21),%r1\\n\"", "\"\\tmtsp\t%r1,%sr0\\n\"", "\"\\tbe\t\t0(%sr0,%r21)\\n\"", "\"\\tldw\t\t44(%r20),%r29\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\tmfia\t%r31\\n\"", "\"\\tldd\t24(%r31),%r27\\n\"", "\"\\tldd\t32(%r31),%r31\\n\"", "\"\\tldd\t16(%r27),%r1\\n\"", "\"\\tbve\t(%r1)\\n\"", "\"\\tldd\t24(%r27),%r27\\n\"", "\"\\t.dword 0 ; fptr\\n\"", "\"\\t.dword 0 ; static link\\n\"" ]

[]

[ "<s>", "void", "rs6000_activate_target_options", "(", "tree", "new_tree", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "rs6000_previous_fndecl", "=", "NULL_TREE", ";", "}", "</s>" ]

[ "Restore", "target", "'s", "globals", "from", "NEW_TREE", "and", "invalidate", "the", "rs6000_previous_fndecl", "cache", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "loongarch_extend_comparands", "(", "rtx_code", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "word_mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "op0", ")", ")", ")", "{", "if", "(", "unsigned_condition", "(", "code", ")", "==", "code", "&&", "GET_MODE", "(", "*", "op0", ")", "==", "QImode", ")", "{", "*", "op0", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "CONST_INT_P", "(", "*", "op1", ")", ")", "*", "op1", "=", "GEN_INT", "(", "(", "uint8_t", ")", "INTVAL", "(", "*", "op1", ")", ")", ";", "else", "*", "op1", "=", "gen_rtx_ZERO_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "else", "{", "*", "op0", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "*", "op1", "!=", "const0_rtx", ")", "*", "op1", "=", "gen_rtx_SIGN_EXTEND", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "}", "}", "</s>" ]

[ "Sign-", "or", "zero-extend", "OP0", "and", "OP1", "for", "integer", "comparisons", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "void", "iq2000_emit_frame_related_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "dwarf_address", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "rtx", "dwarf_mem", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "dwarf_address", ")", ";", "iq2000_annotate_frame_insn", "(", "emit_move_insn", "(", "mem", ",", "reg", ")", ",", "gen_rtx_SET", "(", "GET_MODE", "(", "reg", ")", ",", "dwarf_mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "instruction", "that", "stores", "REG", "in", "MEM", ".", "Make", "the", "instruction", "frame", "related", "and", "note", "that", "it", "stores", "REG", "at", "(", "SP", "+", "OFFSET", ")", "." ]

[ "iq2000" ]

[]

[ "<s>", "void", "visium_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "visium_init_machine_status", ";", "}", "</s>" ]

[ "The", "per-function", "data", "machinery", "is", "needed", "to", "indicate", "when", "a", "frame", "is", "required", "." ]

[ "visium" ]

[]

[ "<s>", "static", "void", "chk_function_decl", "(", "const_tree", "fntype", ",", "location_t", "call_location", ")", "{", "if", "(", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "fntype", ")", ")", "&&", "pru_return_in_memory", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fntype", ")", ")", "error_at", "(", "call_location", ",", "\"large return values not supported with %<-mabi=ti%> option\"", ")", ";", "for", "(", "tree", "p", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "p", ";", "p", "=", "TREE_CHAIN", "(", "p", ")", ")", "{", "tree", "arg_type", "=", "TREE_VALUE", "(", "p", ")", ";", "if", "(", "chkp_type_has_function_pointer", "(", "arg_type", ")", ")", "error_at", "(", "call_location", ",", "\"function pointers not supported with %<-mabi=ti%> option\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "the", "function", "declaration", "FNTYPE", "for", "TI", "ABI", "compatibility", "." ]

[ "pru", "\"large return values not supported with %<-mabi=ti%> option\"", "\"function pointers not supported with %<-mabi=ti%> option\"" ]

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "uint8_t", "Scope", "=", "SP", "->", "isLocalToUnit", "(", ")", "?", "BTF", "::", "FUNC_STATIC", ":", "BTF", "::", "FUNC_GLOBAL", ";", "auto", "FuncTypeEntry", "=", "std", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ",", "Scope", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "processDeclAnnotations", "(", "DV", "->", "getAnnotations", "(", ")", ",", "FuncTypeId", ",", "Arg", "-", "1", ")", ";", "}", "}", "processDeclAnnotations", "(", "SP", "->", "getAnnotations", "(", ")", ",", "FuncTypeId", ",", "-", "1", ")", ";", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "BTF::FUNC_STATIC", "BTF::FUNC_GLOBAL", "1", "1", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "if", "(", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "AnalyzeFormalArguments", "(", "CCInfo", ",", "Ins", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUASI", ".", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "MF", ")", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "4", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "setABIArgOffset", "(", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "ISD::InputArg", "16", "R600", "R600", "ISD::InputArg", "8", "AMDGPU::isShader", "0", "ISD::InputArg", "AMDGPU::isShader", "AMDGPU::R600_Reg128RegClass", "SI", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "-", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isX18Reserved", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "16" ]

[]

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

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "R600" ]

[]

[ "<s>", "int", "pa_shadd_constant_p", "(", "int", "val", ")", "{", "if", "(", "val", "==", "2", "||", "val", "==", "4", "||", "val", "==", "8", ")", "return", "1", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "given", "constant", "is", "2", ",", "4", ",", "or", "8", ".", "These", "are", "the", "valid", "constants", "for", "shadd", "instructions", "." ]

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

[]

[ "<s>", "static", "void", "or1k_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain", ")", "{", "const", "unsigned", "movhi_r13", "=", "(", "0x06u", "<<", "26", ")", "|", "(", "13", "<<", "21", ")", ";", "const", "unsigned", "movhi_r11", "=", "(", "0x06u", "<<", "26", ")", "|", "(", "11", "<<", "21", ")", ";", "const", "unsigned", "ori_r13_r13", "=", "(", "0x2a", "<<", "26", ")", "|", "(", "13", "<<", "21", ")", "|", "(", "13", "<<", "16", ")", ";", "const", "unsigned", "ori_r11_r11", "=", "(", "0x2a", "<<", "26", ")", "|", "(", "11", "<<", "21", ")", "|", "(", "11", "<<", "16", ")", ";", "const", "unsigned", "jr_r13", "=", "(", "0x11", "<<", "26", ")", "|", "(", "13", "<<", "11", ")", ";", "rtx", "tramp", "[", "5", "]", ",", "fnaddr", ",", "f_hi", ",", "f_lo", ",", "c_hi", ",", "c_lo", ";", "fnaddr", "=", "force_operand", "(", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ",", "NULL", ")", ";", "f_hi", "=", "expand_binop", "(", "SImode", ",", "lshr_optab", ",", "fnaddr", ",", "GEN_INT", "(", "16", ")", ",", "NULL", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "f_lo", "=", "expand_binop", "(", "SImode", ",", "and_optab", ",", "fnaddr", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "chain", "=", "force_operand", "(", "chain", ",", "NULL", ")", ";", "c_hi", "=", "expand_binop", "(", "SImode", ",", "lshr_optab", ",", "chain", ",", "GEN_INT", "(", "16", ")", ",", "NULL", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "c_lo", "=", "expand_binop", "(", "SImode", ",", "and_optab", ",", "chain", ",", "GEN_INT", "(", "0xffff", ")", ",", "NULL", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "tramp", "[", "0", "]", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "f_hi", ",", "gen_int_mode", "(", "movhi_r13", ",", "SImode", ")", ",", "f_hi", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "tramp", "[", "1", "]", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "c_hi", ",", "gen_int_mode", "(", "movhi_r11", ",", "SImode", ")", ",", "c_hi", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "tramp", "[", "2", "]", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "f_lo", ",", "gen_int_mode", "(", "ori_r13_r13", ",", "SImode", ")", ",", "f_lo", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "tramp", "[", "4", "]", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "c_lo", ",", "gen_int_mode", "(", "ori_r11_r11", ",", "SImode", ")", ",", "c_lo", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "tramp", "[", "3", "]", "=", "gen_int_mode", "(", "jr_r13", ",", "SImode", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "5", ";", "++", "i", ")", "{", "rtx", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "i", "*", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "tramp", "[", "i", "]", ")", ";", "}", "}", "</s>" ]

[ "Worker", "for", "TARGET_TRAMPOLINE_INIT", ".", "This", "is", "called", "to", "initialize", "a", "trampoline", ".", "The", "argument", "M_TRAMP", "is", "an", "RTX", "for", "the", "memory", "block", "to", "be", "initialized", "with", "trampoline", "code", ".", "The", "argument", "FNDECL", "contains", "the", "definition", "of", "the", "nested", "function", "to", "be", "called", ",", "we", "use", "this", "to", "get", "the", "function", "'s", "address", ".", "The", "argument", "CHAIN", "is", "an", "RTX", "for", "the", "static", "chain", "value", "to", "be", "passed", "to", "the", "nested", "function", "." ]

[ "or1k", "0x06u", "26", "13", "21", "0x06u", "26", "11", "21", "0x2a", "26", "13", "21", "13", "16", "0x2a", "26", "11", "21", "11", "16", "0x11", "26", "13", "11", "5", "0", "16", "0xffff", "16", "0xffff", "0", "1", "2", "4", "3", "0", "5", "4" ]

[]

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

[ "If", "target", "has", "efficient", "vector", "element", "load/store", "instructions", ",", "it", "can", "return", "true", "here", "so", "that", "insertion/extraction", "costs", "are", "not", "added", "to", "the", "scalarization", "cost", "of", "a", "load/store", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Spill callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</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", "(", ")", "." ]

[ "ARC", "ARC", "\"Spill callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "void", "ARMTargetStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ",", "char", "Suffix", ")", "{", "unsigned", "Size", ";", "char", "Buffer", "[", "4", "]", ";", "const", "bool", "LittleEndian", "=", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "switch", "(", "Suffix", ")", "{", "case", "'\\0'", ":", "Size", "=", "4", ";", "for", "(", "unsigned", "II", "=", "0", ",", "IE", "=", "Size", ";", "II", "!=", "IE", ";", "II", "++", ")", "{", "const", "unsigned", "I", "=", "LittleEndian", "?", "(", "Size", "-", "II", "-", "1", ")", ":", "II", ";", "Buffer", "[", "Size", "-", "II", "-", "1", "]", "=", "uint8_t", "(", "Inst", ">>", "I", "*", "CHAR_BIT", ")", ";", "}", "break", ";", "case", "'n'", ":", "case", "'w'", ":", "Size", "=", "(", "Suffix", "==", "'n'", "?", "2", ":", "4", ")", ";", "for", "(", "unsigned", "II", "=", "0", ",", "IE", "=", "Size", ";", "II", "!=", "IE", ";", "II", "=", "II", "+", "2", ")", "{", "const", "unsigned", "I0", "=", "LittleEndian", "?", "II", "+", "0", ":", "II", "+", "1", ";", "const", "unsigned", "I1", "=", "LittleEndian", "?", "II", "+", "1", ":", "II", "+", "0", ";", "Buffer", "[", "Size", "-", "II", "-", "2", "]", "=", "uint8_t", "(", "Inst", ">>", "I0", "*", "CHAR_BIT", ")", ";", "Buffer", "[", "Size", "-", "II", "-", "1", "]", "=", "uint8_t", "(", "Inst", ">>", "I1", "*", "CHAR_BIT", ")", ";", "}", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid Suffix\"", ")", ";", "}", "getStreamer", "(", ")", ".", "emitBytes", "(", "StringRef", "(", "Buffer", ",", "Size", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "0", "1", "1", "2", "4", "0", "2", "0", "1", "1", "0", "2", "1", "\"Invalid Suffix\"" ]

[]

[ "<s>", "Instruction", "*", "PPCTargetLowering", "::", "emitLeadingFence", "(", "IRBuilderBase", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "if", "(", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_sync", ")", ";", "if", "(", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_lwsync", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_sync", "Intrinsic::ppc_lwsync" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Dot", ")", ";", "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", ")", ";", "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" ]

[]

[ "<s>", "unsigned", "int", "aarch64_tlsdesc_abi_id", "(", ")", "{", "predefined_function_abi", "&", "tlsdesc_abi", "=", "function_abis", "[", "ARM_PCS_TLSDESC", "]", ";", "if", "(", "!", "tlsdesc_abi", ".", "initialized_p", "(", ")", ")", "{", "HARD_REG_SET", "full_reg_clobbers", ";", "CLEAR_HARD_REG_SET", "(", "full_reg_clobbers", ")", ";", "SET_HARD_REG_BIT", "(", "full_reg_clobbers", ",", "R0_REGNUM", ")", ";", "SET_HARD_REG_BIT", "(", "full_reg_clobbers", ",", "CC_REGNUM", ")", ";", "for", "(", "int", "regno", "=", "P0_REGNUM", ";", "regno", "<=", "P15_REGNUM", ";", "++", "regno", ")", "SET_HARD_REG_BIT", "(", "full_reg_clobbers", ",", "regno", ")", ";", "tlsdesc_abi", ".", "initialize", "(", "ARM_PCS_TLSDESC", ",", "full_reg_clobbers", ")", ";", "}", "return", "tlsdesc_abi", ".", "id", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "ID", "of", "the", "TLDESC", "ABI", ",", "initializing", "the", "descriptor", "if", "has", "n't", "been", "already", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "AVR" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "STI", ".", "hasMiscellaneousExtensions3", "(", ")", ")", "Opc", "=", "SystemZ", "::", "SELRMux", ";", "else", "if", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "Opc", "=", "SystemZ", "::", "LOCRMux", ";", "else", "{", "Opc", "=", "SystemZ", "::", "LOCR", ";", "MRI", ".", "constrainRegClass", "(", "DstReg", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "unsigned", "TReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "unsigned", "FReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "TReg", ")", ".", "addReg", "(", "TrueReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "FReg", ")", ".", "addReg", "(", "FalseReg", ")", ";", "TrueReg", "=", "TReg", ";", "FalseReg", "=", "FReg", ";", "}", "}", "else", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "STI", ".", "hasMiscellaneousExtensions3", "(", ")", ")", "Opc", "=", "SystemZ", "::", "SELGR", ";", "else", "Opc", "=", "SystemZ", "::", "LOCGR", ";", "}", "else", "llvm_unreachable", "(", "\"Invalid register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "SystemZ::GRX32BitRegClass", "SystemZ::SELRMux", "SystemZ::LOCRMux", "SystemZ::LOCR", "SystemZ::GR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "SystemZ::SELGR", "SystemZ::LOCGR", "\"Invalid register class\"" ]

[]

[ "<s>", "enum", "reg_class", "secondary_input_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "enum", "reg_class", "default_class", "=", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "?", "DPREGS", ":", "DREGS", ";", "enum", "reg_class", "x_class", "=", "NO_REGS", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "code", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ",", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "==", "-", "1", ")", "code", "=", "MEM", ";", "else", "x_class", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "}", "if", "(", "fp_plus_const_operand", "(", "x", ",", "mode", ")", ")", "{", "rtx", "op2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "int", "large_constant_p", "=", "!", "CONST_7BIT_IMM_P", "(", "INTVAL", "(", "op2", ")", ")", ";", "if", "(", "class", "==", "PREGS", "||", "class", "==", "PREGS_CLOBBERED", ")", "return", "NO_REGS", ";", "if", "(", "class", "==", "DREGS", "||", "class", "==", "DPREGS", ")", "return", "large_constant_p", "?", "PREGS", ":", "NO_REGS", ";", "return", "PREGS", ";", "}", "if", "(", "x_class", "==", "AREGS", ")", "return", "class", "==", "DREGS", "||", "class", "==", "AREGS", "?", "NO_REGS", ":", "DREGS", ";", "if", "(", "class", "==", "AREGS", ")", "{", "if", "(", "x", "!=", "const0_rtx", "&&", "x_class", "!=", "DREGS", ")", "return", "DREGS", ";", "else", "return", "NO_REGS", ";", "}", "if", "(", "class", "==", "CCREGS", "&&", "x_class", "!=", "DREGS", ")", "return", "DREGS", ";", "if", "(", "x_class", "==", "CCREGS", "&&", "class", "!=", "DREGS", ")", "return", "DREGS", ";", "if", "(", "code", "==", "MEM", ")", "if", "(", "!", "reg_class_subset_p", "(", "class", ",", "default_class", ")", ")", "return", "default_class", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "a", "register", "in", "CLASS", "requires", "an", "extra", "scratch", "register", ".", "Return", "the", "class", "needed", "for", "the", "scratch", "register", "." ]

[ "bfin", "4", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "if", "(", "isForcedVOP3", "(", ")", ")", "{", "AMDGPUOperand", "&", "LastOp", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "Operands", ".", "size", "(", ")", "-", "1", "]", ")", ";", "if", "(", "LastOp", ".", "isRegKind", "(", ")", "||", "(", "LastOp", ".", "isImm", "(", ")", "&&", "LastOp", ".", "getImmTy", "(", ")", "!=", "AMDGPUOperand", "::", "ImmTyNone", ")", ")", "{", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyClamp", ")", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyOMod", ")", ")", ";", "bool", "Res", "=", "MatchAndEmitInstruction", "(", "IDLoc", ",", "Opcode", ",", "Operands", ",", "Out", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "if", "(", "!", "Res", ")", "return", "Res", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "\"unrecognized instruction mnemonic\"", "0ULL", "AMDGPU", "AMDGPU", "1", "AMDGPU", "AMDGPU", "0", "AMDGPU", "AMDGPU", "0", "AMDGPU", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "PTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "sizeof", "(", "map", ")", "/", "sizeof", "(", "map", "[", "0", "]", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "map", "[", "i", "]", ".", "cls", "==", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "map", "[", "i", "]", ".", "opcode", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "AddDefaultPredicate", "(", "MI", ")", ";", "return", ";", "}", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "0", "0", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "void", "X86AvoidSFBPass", "::", "buildCopy", "(", "MachineInstr", "*", "LoadInst", ",", "unsigned", "NLoadOpcode", ",", "int64_t", "LoadDisp", ",", "MachineInstr", "*", "StoreInst", ",", "unsigned", "NStoreOpcode", ",", "int64_t", "StoreDisp", ",", "unsigned", "Size", ",", "int64_t", "LMMOffset", ",", "int64_t", "SMMOffset", ")", "{", "MachineOperand", "&", "LoadBase", "=", "getBaseOperand", "(", "LoadInst", ")", ";", "MachineOperand", "&", "StoreBase", "=", "getBaseOperand", "(", "StoreInst", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "LoadInst", "->", "getParent", "(", ")", ";", "MachineMemOperand", "*", "LMMO", "=", "*", "LoadInst", "->", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "SMMO", "=", "*", "StoreInst", "->", "memoperands_begin", "(", ")", ";", "unsigned", "Reg1", "=", "MRI", "->", "createVirtualRegister", "(", "TII", "->", "getRegClass", "(", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "0", ",", "TRI", ",", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", ";", "MachineInstr", "*", "NewLoad", "=", "BuildMI", "(", "*", "MBB", ",", "LoadInst", ",", "LoadInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "Reg1", ")", ".", "add", "(", "LoadBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "LoadDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "LMMO", ",", "LMMOffset", ",", "Size", ")", ")", ";", "if", "(", "LoadBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewLoad", ")", ".", "setIsKill", "(", "false", ")", ";", "LLVM_DEBUG", "(", "NewLoad", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "if", "(", "StoreInst", "->", "getPrevNode", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "MachineInstr", "*", "NewStore", "=", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "if", "(", "StoreBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewStore", ")", ".", "setIsKill", "(", "false", ")", ";", "MachineOperand", "&", "StoreSrcVReg", "=", "StoreInst", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ";", "assert", "(", "StoreSrcVReg", ".", "isReg", "(", ")", "&&", "\"Expected virtual register\"", ")", ";", "NewStore", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "setIsKill", "(", "StoreSrcVReg", ".", "isKill", "(", ")", ")", ";", "LLVM_DEBUG", "(", "NewStore", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "COPY", "Op", "." ]

[ "X86", "X86", "0", "1", "X86::NoRegister", "X86::NoRegister", "1", "X86::NoRegister", "X86::NoRegister", "X86::AddrNumOperands", "\"Expected virtual register\"", "X86::AddrNumOperands" ]

[]

[ "<s>", "static", "int", "ix86_vec_cost", "(", "machine_mode", "mode", ",", "int", "cost", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "cost", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "128", "&&", "TARGET_SSE_SPLIT_REGS", ")", "return", "cost", "*", "2", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "128", "&&", "TARGET_AVX256_SPLIT_REGS", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "128", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "vector", "operation", "in", "MODE", "given", "that", "scalar", "version", "has", "COST", ".", "If", "PARALLEL", "is", "true", "assume", "that", "CPU", "has", "more", "than", "one", "unit", "performing", "the", "operation", "." ]

[ "i386", "128", "2", "128", "128" ]

[]

[ "<s>", "AsmToken", "LexToken", "(", ")", "{", "if", "(", "!", "Lexer", ")", "{", "SetError", "(", "SMLoc", "(", ")", ",", "\"No MCAsmLexer installed\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "}", "switch", "(", "AsmInfo", ".", "getAssemblerDialect", "(", ")", ")", "{", "default", ":", "SetError", "(", "SMLoc", "(", ")", ",", "\"Unhandled dialect\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "case", "0", ":", "return", "LexTokenUAL", "(", ")", ";", "}", "}", "</s>" ]

[ "LexToken", "-", "Read", "the", "next", "token", "and", "return", "its", "code", "." ]

[ "MBlaze", "\"No MCAsmLexer installed\"", "\"\"", "0", "\"Unhandled dialect\"", "\"\"", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_emit_compare", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "need_eq_ne_p", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp_operands", "[", "0", "]", ")", ")", "==", "MODE_INT", ")", "{", "if", "(", "!", "need_eq_ne_p", "&&", "cmp_operands", "[", "1", "]", "==", "const0_rtx", ")", "{", "*", "op0", "=", "cmp_operands", "[", "0", "]", ";", "*", "op1", "=", "cmp_operands", "[", "1", "]", ";", "}", "else", "if", "(", "*", "code", "==", "EQ", "||", "*", "code", "==", "NE", ")", "{", "if", "(", "need_eq_ne_p", ")", "{", "*", "op0", "=", "mips_zero_if_equal", "(", "cmp_operands", "[", "0", "]", ",", "cmp_operands", "[", "1", "]", ")", ";", "*", "op1", "=", "const0_rtx", ";", "}", "else", "{", "*", "op0", "=", "cmp_operands", "[", "0", "]", ";", "*", "op1", "=", "force_reg", "(", "GET_MODE", "(", "*", "op0", ")", ",", "cmp_operands", "[", "1", "]", ")", ";", "}", "}", "else", "{", "bool", "invert", "=", "false", ";", "*", "op0", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "cmp_operands", "[", "0", "]", ")", ")", ";", "*", "op1", "=", "const0_rtx", ";", "mips_emit_int_relational", "(", "*", "code", ",", "&", "invert", ",", "*", "op0", ",", "cmp_operands", "[", "0", "]", ",", "cmp_operands", "[", "1", "]", ")", ";", "*", "code", "=", "(", "invert", "?", "EQ", ":", "NE", ")", ";", "}", "}", "else", "{", "enum", "rtx_code", "cmp_code", ";", "switch", "(", "*", "code", ")", "{", "case", "NE", ":", "case", "LTGT", ":", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition_maybe_unordered", "(", "*", "code", ")", ";", "*", "code", "=", "EQ", ";", "break", ";", "default", ":", "cmp_code", "=", "*", "code", ";", "*", "code", "=", "NE", ";", "break", ";", "}", "*", "op0", "=", "(", "ISA_HAS_8CC", "?", "gen_reg_rtx", "(", "CCmode", ")", ":", "gen_rtx_REG", "(", "CCmode", ",", "FPSW_REGNUM", ")", ")", ";", "*", "op1", "=", "const0_rtx", ";", "mips_emit_binary", "(", "cmp_code", ",", "*", "op0", ",", "cmp_operands", "[", "0", "]", ",", "cmp_operands", "[", "1", "]", ")", ";", "}", "}", "</s>" ]

[ "Convert", "a", "comparison", "into", "something", "that", "can", "be", "used", "in", "a", "branch", "or", "conditional", "move", ".", "On", "entry", ",", "*", "OP0", "and", "*", "OP1", "are", "the", "values", "being", "compared", "and", "*", "CODE", "is", "the", "code", "used", "to", "compare", "them", ".", "Update", "*", "CODE", ",", "*", "OP0", "and", "*", "OP1", "so", "that", "they", "describe", "the", "final", "comparison", ".", "If", "NEED_EQ_NE_P", ",", "then", "only", "EQ", "or", "NE", "comparisons", "against", "zero", "are", "possible", ",", "otherwise", "any", "standard", "branch", "condition", "can", "be", "used", ".", "The", "standard", "branch", "conditions", "are", ":", "-", "EQ", "or", "NE", "between", "two", "registers", ".", "-", "any", "comparison", "between", "a", "register", "and", "zero", "." ]

[ "mips", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "LW", ")", "||", "(", "Opc", "==", "Mips", "::", "LD", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164", ")", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "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", "." ]

[ "Mips", "Mips", "Mips::LW", "Mips::LD", "Mips::LWC1", "Mips::LDC1", "Mips::LDC164", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "static", "inline", "tree", "compound_expr", "(", "tree", "t1", ",", "tree", "t2", ")", "{", "return", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "t1", ",", "t2", ")", ";", "}", "</s>" ]

[ "Return", "the", "compound", "expression", "made", "of", "T1", "and", "T2", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "arm", "100", "1" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_ssemov", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SSEMOV", "||", "mode", "!=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", "gcc_unreachable", "(", ")", ";", "enum", "attr_mode", "insn_mode", "=", "get_attr_mode", "(", "insn", ")", ";", "switch", "(", "insn_mode", ")", "{", "case", "MODE_XI", ":", "case", "MODE_V8DF", ":", "case", "MODE_V16SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "64", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_OI", ":", "case", "MODE_V4DF", ":", "case", "MODE_V8SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "32", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_TI", ":", "case", "MODE_V2DF", ":", "case", "MODE_V4SF", ":", "return", "ix86_get_ssemov", "(", "operands", ",", "16", ",", "insn_mode", ",", "mode", ")", ";", "case", "MODE_DI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "HAVE_AS_IX86_INTERUNIT_MOVQ", ")", "return", "\"%vmovq\\t{%1, %q0|%q0, %1}\"", ";", "else", "return", "\"%vmovd\\t{%1, %q0|%q0, %1}\"", ";", "}", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "HAVE_AS_IX86_INTERUNIT_MOVQ", ")", "return", "\"%vmovq\\t{%q1, %0|%0, %q1}\"", ";", "else", "return", "\"%vmovd\\t{%q1, %0|%0, %q1}\"", ";", "}", "else", "return", "\"%vmovq\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_SI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"%vmovd\\t{%1, %k0|%k0, %1}\"", ";", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"%vmovd\\t{%k1, %0|%0, %k1}\"", ";", "else", "return", "\"%vmovd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_HI", ":", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vmovw\\t{%1, %k0|%k0, %1}\"", ";", "else", "if", "(", "GENERAL_REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovw\\t{%k1, %0|%0, %k1}\"", ";", "else", "return", "\"vmovw\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_DF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovsd\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"%vmovsd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_SF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovss\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"%vmovss\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_HF", ":", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "\"vmovsh\\t{%d1, %0|%0, %d1}\"", ";", "else", "return", "\"vmovsh\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_V1DF", ":", "gcc_assert", "(", "!", "TARGET_AVX", ")", ";", "return", "\"movlpd\\t{%1, %0|%0, %1}\"", ";", "case", "MODE_V2SF", ":", "if", "(", "TARGET_AVX", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"vmovlps\\t{%1, %d0|%d0, %1}\"", ";", "else", "return", "\"%vmovlps\\t{%1, %0|%0, %1}\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "template", "of", "the", "TYPE_SSEMOV", "instruction", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "i386", "0", "1", "64", "32", "16", "0", "\"%vmovq\\t{%1, %q0|%q0, %1}\"", "\"%vmovd\\t{%1, %q0|%q0, %1}\"", "1", "\"%vmovq\\t{%q1, %0|%0, %q1}\"", "\"%vmovd\\t{%q1, %0|%0, %q1}\"", "\"%vmovq\\t{%1, %0|%0, %1}\"", "0", "\"%vmovd\\t{%1, %k0|%k0, %1}\"", "1", "\"%vmovd\\t{%k1, %0|%0, %k1}\"", "\"%vmovd\\t{%1, %0|%0, %1}\"", "0", "\"vmovw\\t{%1, %k0|%k0, %1}\"", "1", "\"vmovw\\t{%k1, %0|%0, %k1}\"", "\"vmovw\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovsd\\t{%d1, %0|%0, %d1}\"", "\"%vmovsd\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovss\\t{%d1, %0|%0, %d1}\"", "\"%vmovss\\t{%1, %0|%0, %1}\"", "0", "1", "\"vmovsh\\t{%d1, %0|%0, %d1}\"", "\"vmovsh\\t{%1, %0|%0, %1}\"", "\"movlpd\\t{%1, %0|%0, %1}\"", "0", "\"vmovlps\\t{%1, %d0|%d0, %1}\"", "\"%vmovlps\\t{%1, %0|%0, %1}\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "SaveMBBI", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMBBI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "SystemZInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SystemZFrameLowering", "*", "TFI", "=", "static_cast", "<", "const", "SystemZFrameLowering", "*", ">", "(", "TM", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "Base", "=", "getFrameRegister", "(", "MF", ")", ";", "uint64_t", "Offset", "=", "TFI", "->", "getEmergencySpillSlotOffset", "(", "MF", ")", ";", "DebugLoc", "DL", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "TII", ".", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "BuildMI", "(", "MBB", ",", "SaveMBBI", ",", "DL", ",", "TII", ".", "get", "(", "StoreOpcode", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "Base", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "UseMBBI", ",", "DL", ",", "TII", ".", "get", "(", "LoadOpcode", ")", ",", "Reg", ")", ".", "addReg", "(", "Base", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_lo16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_ha16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_lo14\"", ",", "16", ",", "14", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "PowerPC", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_lo16\"", "16", "16", "0", "\"fixup_ppc_ha16\"", "16", "16", "0", "\"fixup_ppc_lo14\"", "16", "14", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "SystemZ", "::", "R6D", ",", "SystemZ", "::", "R7D", ",", "SystemZ", "::", "R8D", ",", "SystemZ", "::", "R9D", ",", "SystemZ", "::", "R10D", ",", "SystemZ", "::", "R11D", ",", "SystemZ", "::", "R12D", ",", "SystemZ", "::", "R13D", ",", "SystemZ", "::", "R14D", ",", "SystemZ", "::", "R15D", ",", "SystemZ", "::", "F8D", ",", "SystemZ", "::", "F9D", ",", "SystemZ", "::", "F10D", ",", "SystemZ", "::", "F11D", ",", "SystemZ", "::", "F12D", ",", "SystemZ", "::", "F13D", ",", "SystemZ", "::", "F14D", ",", "SystemZ", "::", "F15D", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R8D", "SystemZ::R9D", "SystemZ::R10D", "SystemZ::R11D", "SystemZ::R12D", "SystemZ::R13D", "SystemZ::R14D", "SystemZ::R15D", "SystemZ::F8D", "SystemZ::F9D", "SystemZ::F10D", "SystemZ::F11D", "SystemZ::F12D", "SystemZ::F13D", "SystemZ::F14D", "SystemZ::F15D", "0" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "addPass", "(", "createIndirectBrExpandPass", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "addPass", "(", "createCFGuardDispatchPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "auto", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", "||", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCVABI", "::", "getBPReg", "(", ")", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "RISCV", "RISCV", "RISCV", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV", "RISCV::X8", "RISCVABI::getBPReg" ]

[]

[ "<s>", "static", "rtx", "aarch64_move_pointer", "(", "rtx", "pointer", ",", "poly_int64", "amount", ")", "{", "rtx", "next", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "pointer", ",", "0", ")", ",", "amount", ")", ";", "return", "adjust_automodify_address", "(", "pointer", ",", "GET_MODE", "(", "pointer", ")", ",", "next", ",", "amount", ")", ";", "}", "</s>" ]

[ "Return", "a", "new", "RTX", "holding", "the", "result", "of", "moving", "POINTER", "forward", "by", "AMOUNT", "bytes", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "StackAlign", ")", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "Amount", ")", "{", "int", "Offset", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ",", "false", ")", ";", "}", "return", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SparcAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "case", "'f'", ":", "case", "'r'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "X86", "::", "JMP_1", "&&", "X86", "::", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "X86", "::", "COND_INVALID", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"code size not handled\"", "0", "X86::JMP_1", "X86::getCondFromBranchOpc", "X86::COND_INVALID" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMBaseInstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "MachineBasicBlock", "::", "iterator", "CallPt", ";", "unsigned", "Opc", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "Opc", "=", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "isThumb", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "MIB", ")", ";", "return", "It", ";", "}", "Opc", "=", "isThumb", "?", "ARM", "::", "tBL", ":", "ARM", "::", "BL", ";", "MachineInstrBuilder", "CallMIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "isThumb", ")", "CallMIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "CallMIB", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerNoLRSave", "||", "C", ".", "CallConstructionID", "==", "MachineOutlinerThunk", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "return", "It", ";", "}", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerRegSave", ")", "{", "unsigned", "Reg", "=", "findRegisterToSaveLRTo", "(", "C", ")", ";", "assert", "(", "Reg", "!=", "0", "&&", "\"No callee-saved register available?\"", ")", ";", "copyPhysReg", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "Reg", ",", "ARM", "::", "LR", ",", "true", ")", ";", "CallPt", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "copyPhysReg", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "ARM", "::", "LR", ",", "Reg", ",", "true", ")", ";", "It", "--", ";", "return", "CallPt", ";", "}", "saveLROnStack", "(", "MBB", ",", "It", ")", ";", "CallPt", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "restoreLRFromStack", "(", "MBB", ",", "It", ")", ";", "It", "--", ";", "return", "CallPt", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "ARM", "ARM", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARM::tBL", "ARM::BL", "ARMCC::AL", "0", "\"No callee-saved register available?\"", "ARM::LR", "ARM::LR" ]

[]

[ "<s>", "void", "th_mempair_save_restore_regs", "(", "rtx", "operands", "[", "4", "]", ",", "bool", "load_p", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "th_mempair_operands_p", "(", "operands", ",", "load_p", ",", "mode", ")", ")", ";", "th_mempair_order_operands", "(", "operands", ",", "load_p", ",", "mode", ")", ";", "if", "(", "load_p", ")", "th_mempair_restore_regs", "(", "operands", ")", ";", "else", "th_mempair_save_regs", "(", "operands", ")", ";", "}", "</s>" ]

[ "Emit", "a", "mempair", "instruction", "to", "save/restore", "two", "registers", "to/from", "stack", "." ]

[ "riscv", "4" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'P'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "\"no-rip\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"no-rip\"" ]

[]

[ "<s>", "static", "bool", "mips_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2SFmode", ":", "return", "TARGET_PAIRED_SINGLE_FLOAT", ";", "case", "V2HImode", ":", "case", "V4QImode", ":", "return", "TARGET_DSP", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "mips" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Top Releasing \"", ";", "DAG", "->", "dumpNode", "(", "*", "SU", ")", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "AMDGPU", "R600", "\"Top Releasing \"" ]

[]

[ "<s>", "unsigned", "int", "get_ratio", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_MIN_VLEN", "==", "32", ")", "return", "mode_vtype_infos", ".", "ratio_for_min_vlen32", "[", "mode", "]", ";", "else", "return", "mode_vtype_infos", ".", "ratio_for_min_vlen64", "[", "mode", "]", ";", "}", "</s>" ]

[ "Get", "ratio", "according", "to", "machine", "mode", "." ]

[ "riscv", "32" ]

[]

[ "<s>", "bool", "PatmosSPBundling", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "PSPI", "=", "&", "getAnalysis", "<", "PatmosSinglePathInfo", ">", "(", ")", ";", "PostDom", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "PMFI", "=", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "PSPI", "->", "isConverting", "(", "MF", ")", "&&", "STC", ".", "enableBundling", "(", "TM", ".", "getOptLevel", "(", ")", ")", ")", "{", "SPBlocks", "+=", "MF", ".", "size", "(", ")", ";", "doBundlingFunction", "(", "PSPI", "->", "getRootScope", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "KudeyarTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "KudeyarISD", "::", "BR_CC_T", ":", "return", "\"KudeyarISD::BR_CC_T\"", ";", "case", "KudeyarISD", "::", "BR_CC_F", ":", "return", "\"KudeyarISD::BR_CC_F\"", ";", "case", "KudeyarISD", "::", "SELECT_CC_T", ":", "return", "\"KudeyarISD::SELECT_CC_T\"", ";", "case", "KudeyarISD", "::", "SELECT_CC_F", ":", "return", "\"KudeyarISD::SELECT_CC_f\"", ";", "case", "KudeyarISD", "::", "CMPEQ", ":", "return", "\"KudeyarISD::CMPEQ\"", ";", "case", "KudeyarISD", "::", "CMPGT", ":", "return", "\"KudeyarISD::CMPGT\"", ";", "case", "KudeyarISD", "::", "CMPLT", ":", "return", "\"KudeyarISD::CMPLT\"", ";", "case", "KudeyarISD", "::", "CMPGTU", ":", "return", "\"KudeyarISD::CMPGTU\"", ";", "case", "KudeyarISD", "::", "CMPLTU", ":", "return", "\"KudeyarISD::CMPLTU\"", ";", "case", "KudeyarISD", "::", "CALL", ":", "return", "\"KudeyarISD::CALL\"", ";", "case", "KudeyarISD", "::", "RET_FLAG", ":", "return", "\"KudeyarISD::RET_FLAG\"", ";", "case", "KudeyarISD", "::", "RETI_FLAG", ":", "return", "\"KudeyarISD::RETI_FLAG\"", ";", "case", "KudeyarISD", "::", "Wrapper", ":", "return", "\"KudeyarISD::Wrapper\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "KudeyarISD::BR_CC_T", "\"KudeyarISD::BR_CC_T\"", "KudeyarISD::BR_CC_F", "\"KudeyarISD::BR_CC_F\"", "KudeyarISD::SELECT_CC_T", "\"KudeyarISD::SELECT_CC_T\"", "KudeyarISD::SELECT_CC_F", "\"KudeyarISD::SELECT_CC_f\"", "KudeyarISD::CMPEQ", "\"KudeyarISD::CMPEQ\"", "KudeyarISD::CMPGT", "\"KudeyarISD::CMPGT\"", "KudeyarISD::CMPLT", "\"KudeyarISD::CMPLT\"", "KudeyarISD::CMPGTU", "\"KudeyarISD::CMPGTU\"", "KudeyarISD::CMPLTU", "\"KudeyarISD::CMPLTU\"", "KudeyarISD::CALL", "\"KudeyarISD::CALL\"", "KudeyarISD::RET_FLAG", "\"KudeyarISD::RET_FLAG\"", "KudeyarISD::RETI_FLAG", "\"KudeyarISD::RETI_FLAG\"", "KudeyarISD::Wrapper", "\"KudeyarISD::Wrapper\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isFpMLxInstruction", "(", "unsigned", "Opcode", ",", "unsigned", "&", "MulOpc", ",", "unsigned", "&", "AddSubOpc", ",", "bool", "&", "NegAcc", ",", "bool", "&", "HasLane", ")", "const", "{", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "::", "const_iterator", "I", "=", "MLxEntryMap", ".", "find", "(", "Opcode", ")", ";", "if", "(", "I", "==", "MLxEntryMap", ".", "end", "(", ")", ")", "return", "false", ";", "const", "ARM_MLxEntry", "&", "Entry", "=", "ARM_MLxTable", "[", "I", "->", "second", "]", ";", "MulOpc", "=", "Entry", ".", "MulOpc", ";", "AddSubOpc", "=", "Entry", ".", "AddSubOpc", ";", "NegAcc", "=", "Entry", ".", "NegAcc", ";", "HasLane", "=", "Entry", ".", "HasLane", ";", "return", "true", ";", "}", "</s>" ]

[ "isFpMLxInstruction", "-", "This", "version", "also", "returns", "the", "multiply", "opcode", "and", "the", "addition", "/", "subtraction", "opcode", "to", "expand", "to", "." ]

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

[]