Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "DeadCodeElimination", "::", "isDead", "(", "unsigned", "R", ")", "const", "{", "for", "(", "auto", "I", "=", "MRI", ".", "use_begin", "(", "R", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "UseI", "=", "I", "->", "getParent", "(", ")", ";", "if", "(", "UseI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "UseI", "->", "isPHI", "(", ")", ")", "{", "assert", "(", "!", "UseI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", ")", ";", "unsigned", "DR", "=", "UseI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "DR", "==", "R", ")", "continue", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

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

[]

[ "<s>", "static", "void", "maybe_clobber_cond", "(", "rtx_insn", "*", "insn", ",", "int", "clock_var", ")", "{", "int", "n", ",", "idx", ";", "idx", "=", "ss", ".", "jump_cycle_index", ";", "for", "(", "n", "=", "0", ";", "n", "<", "12", ";", "n", "++", ",", "idx", "++", ")", "{", "rtx", "cond", ",", "link", ";", "int", "cycle", ";", "if", "(", "idx", ">=", "12", ")", "idx", "-=", "12", ";", "cycle", "=", "ss", ".", "jump_cycles", "[", "idx", "]", ";", "if", "(", "cycle", "<=", "clock_var", ")", "return", ";", "cond", "=", "ss", ".", "jump_cond", "[", "idx", "]", ";", "if", "(", "cond", "==", "NULL_RTX", ")", "continue", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "ss", ".", "jump_cond", "[", "idx", "]", "=", "NULL_RTX", ";", "continue", ";", "}", "note_stores", "(", "insn", ",", "clobber_cond_1", ",", "ss", ".", "jump_cond", "+", "idx", ")", ";", "for", "(", "link", "=", "REG_NOTES", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_INC", ")", "clobber_cond_1", "(", "XEXP", "(", "link", ",", "0", ")", ",", "NULL_RTX", ",", "ss", ".", "jump_cond", "+", "idx", ")", ";", "}", "}", "</s>" ]

[ "Examine", "INSN", ",", "and", "if", "it", "destroys", "the", "conditions", "have", "recorded", "for", "any", "of", "the", "jumps", "in", "flight", ",", "clear", "that", "condition", "so", "that", "we", "do", "n't", "predicate", "any", "more", "insns", ".", "CLOCK_VAR", "helps", "us", "limit", "the", "search", "to", "only", "those", "jumps", "which", "are", "still", "in", "flight", "." ]

[ "c6x", "0", "12", "12", "12", "1", "0" ]

[]

[ "<s>", "static", "void", "rs6000_init_sched_context", "(", "void", "*", "_sc", ",", "bool", "clean_p", ")", "{", "rs6000_sched_context_t", "sc", "=", "(", "rs6000_sched_context_t", ")", "_sc", ";", "if", "(", "clean_p", ")", "{", "sc", "->", "cached_can_issue_more", "=", "0", ";", "sc", "->", "last_scheduled_insn", "=", "NULL_RTX", ";", "sc", "->", "load_store_pendulum", "=", "0", ";", "}", "else", "{", "sc", "->", "cached_can_issue_more", "=", "cached_can_issue_more", ";", "sc", "->", "last_scheduled_insn", "=", "last_scheduled_insn", ";", "sc", "->", "load_store_pendulum", "=", "load_store_pendulum", ";", "}", "}", "</s>" ]

[ "If", "CLEAN_P", "is", "true", "then", "initializes", "_SC", "with", "clean", "data", ",", "and", "from", "the", "global", "context", "otherwise", "." ]

[ "rs6000", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Instruction Selection\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Instruction Selection\"" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "Val", "=", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Val", "=", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "Val", "=", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "Val", "=", "performXORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SETCC", ":", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nMipsSE DAG Combine:\\n\"", ";", "N", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n=> \\n\"", ";", "Val", ".", "getNode", "(", ")", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Val", ";", "}", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</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", "." ]

[ "Mips", "Mips", "ISD::AND", "ISD::OR", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::XOR", "ISD::SETCC", "\"\\nMipsSE DAG Combine:\\n\"", "\"\\n=> \\n\"", "\"\\n\"", "Mips" ]

[]

[ "<s>", "const", "AVRSubtarget", "*", "AVRTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "{", "return", "&", "SubTarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "AVR", "AVR", "AVR" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enableMachinePipeliner", "(", ")", "const", "{", "return", "getSchedModel", "(", ")", ".", "hasInstrSchedModel", "(", ")", "&&", "useMachinePipeliner", "(", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "MachinePipeliner", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "requiresRegisterScavenging", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "bool", "NeedSP", "=", "!", "Info", "->", "isEntryFunction", "(", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "hasCalls", "(", ")", ";", "if", "(", "NeedSP", ")", "{", "unsigned", "ReservedStackPtrOffsetReg", "=", "TRI", "->", "reservedStackPtrOffsetReg", "(", "MF", ")", ";", "Info", "->", "setStackPtrOffsetReg", "(", "ReservedStackPtrOffsetReg", ")", ";", "assert", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "}", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", ",", "Info", "->", "getScratchWaveOffsetReg", "(", ")", ")", ";", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::SCRATCH_WAVE_OFFSET_REG" ]

[]

[ "<s>", "static", "bool", "avr_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", "ATTRIBUTE_UNUSED", ",", "enum", "by_pieces_operation", "op", ",", "bool", "speed_p", ")", "{", "if", "(", "op", "!=", "MOVE_BY_PIECES", "||", "(", "speed_p", "&&", "(", "size", ">", "(", "MOVE_MAX_PIECES", ")", ")", ")", ")", "return", "default_use_by_pieces_infrastructure_p", "(", "size", ",", "align", ",", "op", ",", "speed_p", ")", ";", "return", "size", "<=", "(", "MOVE_MAX_PIECES", ")", ";", "}", "</s>" ]

[ "Prefer", "sequence", "of", "loads/stores", "for", "moves", "of", "size", "upto", "two", "-", "two", "pairs", "of", "load/store", "instructions", "are", "always", "better", "than", "the", "5", "instruction", "sequence", "for", "a", "loop", "(", "1", "instruction", "for", "loop", "counter", "setup", ",", "and", "4", "for", "the", "body", "of", "the", "loop", ")", "." ]

[ "avr" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "bool", "Clone", "=", "true", ";", "unsigned", "Opc", "=", "Orig", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8r0", ":", "case", "X86", "::", "MOV16r0", ":", "case", "X86", "::", "MOV32r0", ":", "case", "X86", "::", "MOV64r0", ":", "{", "if", "(", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unreachable!\"", ")", ";", "case", "X86", "::", "MOV8r0", ":", "Opc", "=", "X86", "::", "MOV8ri", ";", "break", ";", "case", "X86", "::", "MOV16r0", ":", "Opc", "=", "X86", "::", "MOV16ri", ";", "break", ";", "case", "X86", "::", "MOV32r0", ":", "Opc", "=", "X86", "::", "MOV32ri", ";", "break", ";", "case", "X86", "::", "MOV64r0", ":", "Opc", "=", "X86", "::", "MOV64ri64i32", ";", "break", ";", "}", "Clone", "=", "false", ";", "}", "break", ";", "}", "}", "if", "(", "Clone", ")", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addOperand", "(", "Orig", "->", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "prior", "(", "I", ")", ";", "NewMI", "->", "substituteRegister", "(", "Orig", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::MOV8r0", "X86::MOV16r0", "X86::MOV32r0", "X86::MOV64r0", "\"Unreachable!\"", "X86::MOV8r0", "X86::MOV8ri", "X86::MOV16r0", "X86::MOV16ri", "X86::MOV32r0", "X86::MOV32ri", "X86::MOV64r0", "X86::MOV64ri64i32", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "m68hc11_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "default_ctor_section_asm_out_constructor", "(", "symbol", ",", "priority", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.globl\\t__do_global_ctors\\n\"", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_ASM_CONSTRUCTOR", "." ]

[ "m68hc11", "\"\\t.globl\\t__do_global_ctors\\n\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "return", "needsCmpXchgNb", "(", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "add_sched_insns_for_speculation", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "ENABLE_WA_SPECULATIVE_LOADS", "&&", "!", "ENABLE_WA_SPECULATIVE_SYNCS", "&&", "!", "ENABLE_WA_INDIRECT_CALLS", ")", "return", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "pat", ";", "if", "(", "NOTE_P", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "USE", "||", "GET_CODE", "(", "pat", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "pat", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pat", ")", ">=", "0", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "{", "if", "(", "any_condjump_p", "(", "insn", ")", "&&", "!", "cbranch_predicted_taken_p", "(", "insn", ")", ")", "{", "rtx_insn", "*", "n", "=", "next_real_insn", "(", "insn", ")", ";", "emit_insn_before", "(", "gen_stall", "(", "GEN_INT", "(", "3", ")", ")", ",", "n", ")", ";", "}", "}", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "any_condjump_p", "(", "insn", ")", "&&", "(", "cbranch_predicted_taken_p", "(", "insn", ")", ")", ")", "{", "rtx", "target", "=", "JUMP_LABEL", "(", "insn", ")", ";", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "target", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "get_attr_type", "(", "next", ")", "==", "TYPE_STALL", ")", "continue", ";", "emit_insn_before", "(", "gen_stall", "(", "GEN_INT", "(", "1", ")", ")", ",", "next", ")", ";", "}", "}", "}", "</s>" ]

[ "Called", "just", "before", "the", "final", "scheduling", "pass", ".", "If", "we", "need", "to", "insert", "NOPs", "later", "on", "to", "work", "around", "speculative", "loads", ",", "insert", "special", "placeholder", "insns", "that", "cause", "loads", "to", "be", "delayed", "for", "as", "many", "cycles", "as", "necessary", "(", "and", "possible", ")", ".", "This", "reduces", "the", "number", "of", "NOPs", "we", "need", "to", "add", ".", "The", "dummy", "insns", "we", "generate", "are", "later", "removed", "by", "bfin_gen_bundles", "." ]

[ "bfin", "0", "3", "1" ]

[]

[ "<s>", "Function", "*", "BlackfinIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "const", "Type", "*", "*", "Tys", ",", "unsigned", "numTy", ")", "const", "{", "assert", "(", "!", "isOverloaded", "(", "IntrID", ")", "&&", "\"Blackfin intrinsics are not overloaded\"", ")", ";", "AttrListPtr", "AList", "=", "getAttributes", "(", "(", "bfinIntrinsic", "::", "ID", ")", "IntrID", ")", ";", "return", "cast", "<", "Function", ">", "(", "M", "->", "getOrInsertFunction", "(", "getName", "(", "IntrID", ")", ",", "getType", "(", "M", "->", "getContext", "(", ")", ",", "IntrID", ")", ",", "AList", ")", ")", ";", "}", "</s>" ]

[ "Create", "or", "insert", "an", "LLVM", "Function", "declaration", "for", "an", "intrinsic", ",", "and", "return", "it", "." ]

[ "Blackfin", "\"Blackfin intrinsics are not overloaded\"", "bfinIntrinsic::ID" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "if", "(", "LT", ".", "second", ".", "isFloatingPoint", "(", ")", ")", "return", "LT", ".", "first", "+", "FloatFactor", "*", "getTypeNumElements", "(", "Ty", ")", ";", "}", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "aarch64_expand_sve_vcond", "(", "machine_mode", "data_mode", ",", "machine_mode", "cmp_mode", ",", "rtx", "*", "ops", ")", "{", "machine_mode", "pred_mode", "=", "aarch64_get_mask_mode", "(", "GET_MODE_NUNITS", "(", "cmp_mode", ")", ",", "GET_MODE_SIZE", "(", "cmp_mode", ")", ")", ".", "require", "(", ")", ";", "rtx", "pred", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "cmp_mode", ")", ")", "{", "if", "(", "aarch64_expand_sve_vec_cmp_float", "(", "pred", ",", "GET_CODE", "(", "ops", "[", "3", "]", ")", ",", "ops", "[", "4", "]", ",", "ops", "[", "5", "]", ",", "true", ")", ")", "std", "::", "swap", "(", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ")", ";", "}", "else", "aarch64_expand_sve_vec_cmp_int", "(", "pred", ",", "GET_CODE", "(", "ops", "[", "3", "]", ")", ",", "ops", "[", "4", "]", ",", "ops", "[", "5", "]", ")", ";", "rtvec", "vec", "=", "gen_rtvec", "(", "3", ",", "pred", ",", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ")", ";", "emit_set_insn", "(", "ops", "[", "0", "]", ",", "gen_rtx_UNSPEC", "(", "data_mode", ",", "vec", ",", "UNSPEC_SEL", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "SVE", "vcond", "pattern", "with", "operands", "OPS", ".", "DATA_MODE", "is", "the", "mode", "of", "the", "data", "being", "selected", "and", "CMP_MODE", "is", "the", "mode", "of", "the", "values", "being", "compared", "." ]

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

[]

[ "<s>", "rtx_code", "m68k_output_compare_qi", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "if", "(", "op1", "==", "const0_rtx", ")", "output_asm_insn", "(", "\"tst%.b %d0\"", ",", "ops", ")", ";", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "\"cmpm%.b %1,%0\"", ",", "ops", ")", ";", "else", "if", "(", "REG_P", "(", "op1", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "\"cmp%.b %d0,%d1\"", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "output_asm_insn", "(", "\"cmp%.b %d1,%d0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>" ]

[ "Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "." ]

[ "m68k", "2", "0", "1", "\"tst%.b %d0\"", "\"cmpm%.b %1,%0\"", "\"cmp%.b %d0,%d1\"", "\"cmp%.b %d1,%d0\"" ]

[]

[ "<s>", "static", "bool", "fr30_must_pass_in_stack", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "mode", "==", "BLKmode", ")", "return", "true", ";", "if", "(", "type", "==", "NULL", ")", "return", "false", ";", "return", "AGGREGATE_TYPE_P", "(", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "pass", "an", "argument", "on", "the", "stack", "rather", "than", "in", "registers", "." ]

[ "fr30" ]

[]

[ "<s>", "void", "s390_expand_vec_compare", "(", "rtx", "target", ",", "enum", "rtx_code", "cond", ",", "rtx", "cmp_op1", ",", "rtx", "cmp_op2", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "bool", "neg_p", "=", "false", ",", "swap_p", "=", "false", ";", "rtx", "tmp", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp_op1", ")", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "switch", "(", "cond", ")", "{", "case", "NE", ":", "cond", "=", "EQ", ";", "neg_p", "=", "true", ";", "break", ";", "case", "UNGT", ":", "cond", "=", "GE", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNGE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cond", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNLE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cond", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNLT", ":", "cond", "=", "GE", ";", "neg_p", "=", "true", ";", "break", ";", "case", "UNEQ", ":", "emit_insn", "(", "gen_vec_cmpuneq", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "LTGT", ":", "emit_insn", "(", "gen_vec_cmpltgt", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "ORDERED", ":", "emit_insn", "(", "gen_vec_ordered", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "UNORDERED", ":", "emit_insn", "(", "gen_vec_unordered", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "default", ":", "break", ";", "}", "}", "else", "{", "switch", "(", "cond", ")", "{", "case", "NE", ":", "cond", "=", "EQ", ";", "neg_p", "=", "true", ";", "break", ";", "case", "GE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "GEU", ":", "cond", "=", "GTU", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "break", ";", "case", "LEU", ":", "cond", "=", "GTU", ";", "neg_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cond", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LTU", ":", "cond", "=", "GTU", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "swap_p", ")", "{", "tmp", "=", "cmp_op1", ";", "cmp_op1", "=", "cmp_op2", ";", "cmp_op2", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_fmt_ee", "(", "cond", ",", "mode", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ")", ";", "if", "(", "neg_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_NOT", "(", "mode", ",", "target", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "comparison", "COND", "of", "CMP_OP1", "and", "CMP_OP2", "and", "store", "the", "result", "in", "TARGET", "." ]

[ "s390" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "get_label_padding", "(", "rtx", "label", ")", "{", "HOST_WIDE_INT", "align", ",", "min_insn_size", ";", "align", "=", "1", "<<", "label_to_alignment", "(", "label", ")", ".", "levels", "[", "0", "]", ".", "log", ";", "min_insn_size", "=", "TARGET_THUMB", "?", "2", ":", "4", ";", "return", "align", ">", "min_insn_size", "?", "align", "-", "min_insn_size", ":", "0", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "amount", "of", "padding", "that", "will", "be", "inserted", "before", "label", "LABEL", "." ]

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

[]

[ "<s>", "static", "inline", "HOST_WIDE_INT", "htm_spr_regno", "(", "enum", "rs6000_builtins", "code", ")", "{", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFHAR", "||", "code", "==", "HTM_BUILTIN_SET_TFHAR", ")", "return", "TFHAR_REGNO", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFIAR", "||", "code", "==", "HTM_BUILTIN_SET_TFIAR", ")", "return", "TFIAR_REGNO", ";", "gcc_assert", "(", "code", "==", "HTM_BUILTIN_GET_TEXASR", "||", "code", "==", "HTM_BUILTIN_SET_TEXASR", "||", "code", "==", "HTM_BUILTIN_GET_TEXASRU", "||", "code", "==", "HTM_BUILTIN_SET_TEXASRU", ")", ";", "return", "TEXASR_REGNO", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SPR", "regno", "associated", "with", "the", "given", "builtin", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "VEFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "VEInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "VERegisterInfo", "&", "RegInfo", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "bool", "NeedsStackRealignment", "=", "RegInfo", ".", "needsStackRealignment", "(", "MF", ")", ";", "if", "(", "!", "NeedsStackRealignment", "&&", "MFI", ".", "getMaxAlign", "(", ")", ">", "getStackAlign", "(", ")", ")", "report_fatal_error", "(", "\"Function \\\"\"", "+", "Twine", "(", "MF", ".", "getName", "(", ")", ")", "+", "\"\\\" required \"", "\"stack re-alignment, but LLVM couldn't handle it \"", "\"(probably because it has a dynamic alloca).\"", ")", ";", "uint64_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "NumBytes", "=", "STI", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "NumBytes", "=", "alignTo", "(", "NumBytes", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "MFI", ".", "setStackSize", "(", "NumBytes", ")", ";", "emitPrologueInsns", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "true", ")", ";", "MaybeAlign", "RuntimeAlign", "=", "NeedsStackRealignment", "?", "MaybeAlign", "(", "MFI", ".", "getMaxAlign", "(", ")", ")", ":", "None", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "-", "(", "int64_t", ")", "NumBytes", ",", "RuntimeAlign", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "VE", "::", "ORri", ")", ",", "VE", "::", "SX17", ")", ".", "addReg", "(", "VE", "::", "SX11", ")", ".", "addImm", "(", "0", ")", ";", "}", "emitSPExtend", "(", "MF", ",", "MBB", ",", "MBBI", ")", ";", "Register", "RegFP", "=", "RegInfo", ".", "getDwarfRegNum", "(", "VE", "::", "SX9", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "RegFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "VE", "VE", "\"Shrink-wrapping not yet supported\"", "VE", "VE", "\"Function \\\"\"", "\"\\\" required \"", "\"stack re-alignment, but LLVM couldn't handle it \"", "\"(probably because it has a dynamic alloca).\"", "VE::ORri", "VE::SX17", "VE::SX11", "0", "VE::SX9" ]

[]

[ "<s>", "static", "bool", "mem_locations_overlap", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "reg1", ",", "reg2", ";", "HOST_WIDE_INT", "off1", ",", "size1", ",", "off2", ",", "size2", ";", "if", "(", "get_memref_parts", "(", "mem1", ",", "&", "reg1", ",", "&", "off1", ",", "&", "size1", ")", "&&", "get_memref_parts", "(", "mem2", ",", "&", "reg2", ",", "&", "off2", ",", "&", "size2", ")", ")", "return", "(", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", ")", "&&", "(", "(", "(", "off1", "<=", "off2", ")", "&&", "(", "off1", "+", "size1", ">", "off2", ")", ")", "||", "(", "(", "off2", "<=", "off1", ")", "&&", "(", "off2", "+", "size2", ">", "off1", ")", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "it", "can", "be", "determined", "that", "the", "two", "MEM", "locations", "overlap", "by", "at", "least", "1", "byte", "based", "on", "base", "reg/offset/size", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "Comet2Subtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Comet2", "Comet2" ]

[]

[ "<s>", "SUnit", "*", "PPCPostRASchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "return", "PostGenericScheduler", "::", "pickNode", "(", "IsTopNode", ")", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<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", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "StackAlign", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", "&&", "!", "MF", ".", "getMMI", "(", ")", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "Amount", ")", "{", "int", "Offset", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "if", "(", "!", "(", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ")", ")", ")", "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", "X86", "0" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "Comet2" ]

[]

[ "<s>", "NVPTXTargetLowering", "::", "ConstraintType", "NVPTXTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "case", "'h'", ":", "case", "'c'", ":", "case", "'l'", ":", "case", "'f'", ":", "case", "'d'", ":", "case", "'0'", ":", "case", "'N'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "1", "0" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "GCNRegPressure", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "SISubtarget", "*", "ST", ")", "const", "{", "OS", "<<", "\"VGPRs: \"", "<<", "getVGRPNum", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumVGPRs", "(", "getVGRPNum", "(", ")", ")", "<<", "')'", ";", "OS", "<<", "\", SGPRs: \"", "<<", "getSGRPNum", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumSGPRs", "(", "getSGRPNum", "(", ")", ")", "<<", "')'", ";", "OS", "<<", "\", LVGPR WT: \"", "<<", "getVGPRTuplesWeight", "(", ")", "<<", "\", LSGPR WT: \"", "<<", "getSGPRTuplesWeight", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\" -> Occ: \"", "<<", "getOccupancy", "(", "*", "ST", ")", ";", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"VGPRs: \"", "\"(O\"", "\", SGPRs: \"", "\"(O\"", "\", LVGPR WT: \"", "\", LSGPR WT: \"", "\" -> Occ: \"" ]

[]

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

[ "Mark", "all", "the", "subexpressions", "of", "the", "PARALLEL", "rtx", "PAR", "as", "frame-related", ".", "Return", "PAR", ".", "dwarf2out.cc", ":", "dwarf2out_frame_debug_expr", "ignores", "sub-expressions", "of", "a", "PARALLEL", "rtx", "other", "than", "the", "first", "if", "they", "do", "not", "have", "the", "FRAME_RELATED", "flag", "set", "on", "them", ".", "So", "this", "function", "is", "handy", "for", "marking", "up", "'enter", "'", "instructions", "." ]

[ "m32c", "0", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "ix86_emit_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "rtx_insn", "*", "insn", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", "--", ">", "0", ";", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "in", "the", "prologue", "." ]

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

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "Z80oldRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "return", "!", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "static", "int", "forward_branch_p", "(", "rtx", "insn", ")", "{", "rtx", "label", "=", "JUMP_LABEL", "(", "insn", ")", ";", "while", "(", "insn", ")", "{", "if", "(", "insn", "==", "label", ")", "break", ";", "else", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "return", "(", "insn", "==", "label", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "INSN", "branches", "forward", ".", "Should", "be", "using", "insn_addresses", "to", "avoid", "walking", "through", "all", "the", "insns", "..." ]

[ "pa" ]

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "llvm_unreachable", "(", "\"AArch64AsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"AArch64AsmBackend::relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "Ty", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "Ty", ")", ")", "return", "false", ";", "unsigned", "EltWidth", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "(", "EltWidth", "==", "32", "&&", "Alignment", ">=", "4", ")", "||", "(", "EltWidth", "==", "16", "&&", "Alignment", ">=", "2", ")", "||", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "UsedList", "=", "AMDGPU", "::", "getUsedList", "(", "M", ")", ";", "bool", "Changed", "=", "processUsedLDS", "(", "M", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "!", "AMDGPU", "::", "isKernel", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "continue", ";", "Changed", "|=", "processUsedLDS", "(", "M", ",", "&", "F", ")", ";", "}", "UsedList", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU::getUsedList", "AMDGPU::isKernel" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "NumOps", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "if", "(", "isBranch", "(", "Inst", ")", "||", "Inst", ".", "getOpcode", "(", ")", "==", "LoongArch", "::", "BL", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch::BL", "1" ]

[]

[ "<s>", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "override", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "PPCSubTarget", "->", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "TRI", "->", "getPointerRegClass", "(", "*", "MF", ",", "1", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "NewOp", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ",", "RC", ")", ",", "0", ")", ";", "OutOps", ".", "push_back", "(", "NewOp", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "MVT::i32", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Videocore", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Videocore_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Videocore_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Videocore_24\"", ",", "0", ",", "24", ",", "0", "}", ",", "{", "\"fixup_Videocore_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_GOT_Global\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_GOT_Local\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_PC24\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Videocore_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Videocore_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Videocore_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Videocore_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Videocore_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_TLSLDM\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_DTPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_DTPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Videocore_Branch_PCRel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore::NumTargetFixupKinds", "\"fixup_Videocore_16\"", "0", "16", "0", "\"fixup_Videocore_32\"", "0", "32", "0", "\"fixup_Videocore_REL32\"", "0", "32", "0", "\"fixup_Videocore_24\"", "0", "24", "0", "\"fixup_Videocore_HI16\"", "0", "16", "0", "\"fixup_Videocore_LO16\"", "0", "16", "0", "\"fixup_Videocore_GPREL16\"", "0", "16", "0", "\"fixup_Videocore_LITERAL\"", "0", "16", "0", "\"fixup_Videocore_GOT_Global\"", "0", "16", "0", "\"fixup_Videocore_GOT_Local\"", "0", "16", "0", "\"fixup_Videocore_PC24\"", "0", "24", "\"fixup_Videocore_CALL16\"", "0", "16", "0", "\"fixup_Videocore_GPREL32\"", "0", "32", "0", "\"fixup_Videocore_SHIFT5\"", "6", "5", "0", "\"fixup_Videocore_SHIFT6\"", "6", "5", "0", "\"fixup_Videocore_64\"", "0", "64", "0", "\"fixup_Videocore_TLSGD\"", "0", "16", "0", "\"fixup_Videocore_GOTTPREL\"", "0", "16", "0", "\"fixup_Videocore_TPREL_HI\"", "0", "16", "0", "\"fixup_Videocore_TPREL_LO\"", "0", "16", "0", "\"fixup_Videocore_TLSLDM\"", "0", "16", "0", "\"fixup_Videocore_DTPREL_HI\"", "0", "16", "0", "\"fixup_Videocore_DTPREL_LO\"", "0", "16", "0", "\"fixup_Videocore_Branch_PCRel\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "Opc", "==", "ISD", "::", "SHL", "&&", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", ")", "return", "false", ";", "if", "(", "(", "Opc", "==", "ISD", "::", "MUL", "||", "Opc", "==", "ISD", "::", "SHL", ")", "&&", "VT", "==", "MVT", "::", "i8", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "for", "the", "given", "node", "type", "." ]

[ "X86", "X86", "ISD::SHL", "MVT::i8", "ISD::MUL", "ISD::SHL", "MVT::i8", "MVT::i16", "ISD::LOAD", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SUB", "ISD::ADD", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR" ]

[]

[ "<s>", "static", "bool", "arc_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "if", "(", "ARC_INTERRUPT_P", "(", "arc_compute_function_type", "(", "cfun", ")", ")", ")", "return", "false", ";", "if", "(", "decl", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_always\"", ",", "attrs", ")", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"secure_call\"", ",", "attrs", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "." ]

[ "arc", "\"jli_always\"", "\"jli_fixed\"", "\"secure_call\"" ]

[]

[ "<s>", "const", "char", "*", "lshrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "4", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %A0\"", "CR_TAB", "\"sbrc %D0,7\"", "CR_TAB", "\"inc %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "32bit", "logic", "shift", "right", "(", "(", "unsigned", "int", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"clr %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "2", "\"clr %C0\"", "\"clr %D0\"", "3", "\"movw %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "4", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "24", "4", "\"mov %A0,%D1\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "31", "6", "\"clr %A0\"", "\"sbrc %D0,7\"", "\"inc %A0\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "\"lsr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\"" ]

[]

[ "<s>", "static", "rtx", "m32c_subreg", "(", "enum", "machine_mode", "outer", ",", "rtx", "x", ",", "enum", "machine_mode", "inner", ",", "int", "byte", ")", "{", "int", "r", ",", "nr", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "SUBREG_BYTE", "(", "x", ")", "==", "0", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "MEM", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "==", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "{", "rtx", "oldx", "=", "x", ";", "x", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "SUBREG_REG", "(", "x", ")", ",", "0", ")", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "x", ",", "SUBREG_REG", "(", "oldx", ")", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "POST_INC", ")", ")", "return", "gen_rtx_MEM", "(", "outer", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MEM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "POST_INC", ")", ")", "return", "gen_rtx_MEM", "(", "outer", ",", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "REG", ")", "return", "simplify_gen_subreg", "(", "outer", ",", "x", ",", "inner", ",", "byte", ")", ";", "r", "=", "REGNO", "(", "x", ")", ";", "if", "(", "r", ">=", "FIRST_PSEUDO_REGISTER", "||", "r", "==", "AP_REGNO", ")", "return", "simplify_gen_subreg", "(", "outer", ",", "x", ",", "inner", ",", "byte", ")", ";", "if", "(", "IS_MEM_REGNO", "(", "r", ")", ")", "return", "simplify_gen_subreg", "(", "outer", ",", "x", ",", "inner", ",", "byte", ")", ";", "if", "(", "byte", "==", "0", ")", "nr", "=", "r", ";", "else", "if", "(", "outer", "==", "HImode", ")", "{", "if", "(", "r", "==", "R0_REGNO", "&&", "byte", "==", "2", ")", "nr", "=", "R2_REGNO", ";", "else", "if", "(", "r", "==", "R0_REGNO", "&&", "byte", "==", "4", ")", "nr", "=", "R1_REGNO", ";", "else", "if", "(", "r", "==", "R0_REGNO", "&&", "byte", "==", "6", ")", "nr", "=", "R3_REGNO", ";", "else", "if", "(", "r", "==", "R1_REGNO", "&&", "byte", "==", "2", ")", "nr", "=", "R3_REGNO", ";", "else", "if", "(", "r", "==", "A0_REGNO", "&&", "byte", "==", "2", ")", "nr", "=", "A1_REGNO", ";", "}", "else", "if", "(", "outer", "==", "SImode", ")", "{", "if", "(", "r", "==", "R0_REGNO", "&&", "byte", "==", "0", ")", "nr", "=", "R0_REGNO", ";", "else", "if", "(", "r", "==", "R0_REGNO", "&&", "byte", "==", "4", ")", "nr", "=", "R1_REGNO", ";", "}", "if", "(", "nr", "==", "-", "1", ")", "{", "fprintf", "(", "stderr", ",", "\"m32c_subreg %s %s %d\\n\"", ",", "mode_name", "[", "outer", "]", ",", "mode_name", "[", "inner", "]", ",", "byte", ")", ";", "debug_rtx", "(", "x", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "outer", ",", "nr", ")", ";", "}", "</s>" ]

[ "Subregs", "are", "non-orthogonal", "for", "us", ",", "because", "our", "registers", "are", "all", "different", "sizes", "." ]

[ "m32c", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "4", "6", "2", "2", "0", "4", "1", "\"m32c_subreg %s %s %d\\n\"" ]

[]

[ "<s>", "void", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "override", "{", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "register_builtin_tuple_types", "(", "vector_type_index", "type", ")", "{", "const", "vector_type_info", "*", "info", "=", "&", "vector_types", "[", "type", "]", ";", "if", "(", "scalar_types", "[", "type", "]", "==", "boolean_type_node", "||", "(", "info", "->", "requires_float", "&&", "!", "TARGET_HAVE_MVE_FLOAT", ")", ")", "return", ";", "const", "char", "*", "vector_type_name", "=", "info", "->", "acle_name", ";", "char", "buffer", "[", "sizeof", "(", "\"float32x4x2_t\"", ")", "]", ";", "for", "(", "unsigned", "int", "num_vectors", "=", "2", ";", "num_vectors", "<=", "4", ";", "num_vectors", "+=", "2", ")", "{", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"%.*sx%d_t\"", ",", "(", "int", ")", "strlen", "(", "vector_type_name", ")", "-", "2", ",", "vector_type_name", ",", "num_vectors", ")", ";", "tree", "vectype", "=", "acle_vector_types", "[", "0", "]", "[", "type", "]", ";", "tree", "arrtype", "=", "build_array_type_nelts", "(", "vectype", ",", "num_vectors", ")", ";", "gcc_assert", "(", "TYPE_MODE_RAW", "(", "arrtype", ")", "==", "TYPE_MODE", "(", "arrtype", ")", ")", ";", "tree", "field", "=", "build_decl", "(", "input_location", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"val\"", ")", ",", "arrtype", ")", ";", "tree", "t", "=", "lang_hooks", ".", "types", ".", "simulate_record_decl", "(", "input_location", ",", "buffer", ",", "make_array_slice", "(", "&", "field", ",", "1", ")", ")", ";", "gcc_assert", "(", "TYPE_MODE_RAW", "(", "t", ")", "==", "TYPE_MODE", "(", "t", ")", ")", ";", "acle_vector_types", "[", "num_vectors", ">>", "1", "]", "[", "type", "]", "=", "TREE_TYPE", "(", "t", ")", ";", "}", "}", "</s>" ]

[ "Register", "tuple", "type", "TYPE", "with", "NUM_VECTORS", "arity", "under", "its", "arm_mve_types.h", "name", "." ]

[ "arm", "\"float32x4x2_t\"", "2", "4", "2", "\"%.*sx%d_t\"", "2", "0", "\"val\"", "1", "1" ]

[]

[ "<s>", "static", "pad_direction", "rs6000_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "AGGREGATE_PADDING_FIXED", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "HOST_WIDE_INT", "size", "=", "0", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "if", "(", "type", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", "==", "1", "||", "size", "==", "2", "||", "size", "==", "4", ")", "return", "PAD_DOWNWARD", ";", "}", "return", "PAD_UPWARD", ";", "}", "if", "(", "AGGREGATES_PAD_UPWARD_ALWAYS", ")", "{", "if", "(", "type", "!=", "0", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "PAD_UPWARD", ";", "}", "return", "default_function_arg_padding", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_PADDING", ".", "For", "the", "AIX", "ABI", "structs", "are", "always", "stored", "left", "shifted", "in", "their", "argument", "slot", "." ]

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

[]

[ "<s>", "bool", "quad_load_store_p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "bool", "ret", ";", "if", "(", "!", "TARGET_QUAD_MEMORY", ")", "ret", "=", "false", ";", "else", "if", "(", "REG_P", "(", "op0", ")", "&&", "MEM_P", "(", "op1", ")", ")", "ret", "=", "(", "quad_int_reg_operand", "(", "op0", ",", "GET_MODE", "(", "op0", ")", ")", "&&", "quad_memory_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "op0", ",", "op1", ")", ")", ";", "else", "if", "(", "MEM_P", "(", "op0", ")", "&&", "REG_P", "(", "op1", ")", ")", "ret", "=", "(", "quad_memory_operand", "(", "op0", ",", "GET_MODE", "(", "op0", ")", ")", "&&", "quad_int_reg_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", ")", ";", "else", "ret", "=", "false", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n========== quad_load_store, return %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load", "or", "store", "quad", "operation", ".", "This", "function", "does", "not", "handle", "the", "atomic", "quad", "memory", "instructions", "." ]

[ "powerpcspe", "\"\\n========== quad_load_store, return %s\\n\"", "\"true\"", "\"false\"" ]

[]

[ "<s>", "unsigned", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "XCore", "::", "R0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "XCore", "XCore::R0" ]

[]

[ "<s>", "bool", "MVEVPTOptimisations", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT Optimisations **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "Modified", "|=", "ReplaceVCMPsByVPNOTs", "(", "MBB", ")", ";", "Modified", "|=", "ReduceOldVCCRValueUses", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT Optimisations **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "DecodeStatus", "PPCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Inst", "=", "IsLittleEndian", "?", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ":", "support", "::", "endian", "::", "read32be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureQPX", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableQPX32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureSPE", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableSPE32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "4", "4", "0", "support::endian", "support::endian", "PPC::FeatureQPX", "PPC::FeatureSPE" ]

[]

[ "<s>", "bool", "SILowerControlFlowPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "HaveKill", "=", "false", ";", "bool", "NeedWQM", "=", "false", ";", "unsigned", "Depth", "=", "0", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "llvm", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "++", "Depth", ";", "If", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "Else", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "Break", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "IfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "ElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "++", "Depth", ";", "Loop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "--", "Depth", "==", "0", "&&", "HaveKill", ")", "{", "SkipIfDead", "(", "MI", ")", ";", "HaveKill", "=", "false", ";", "}", "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "if", "(", "Depth", "==", "0", ")", "SkipIfDead", "(", "MI", ")", ";", "else", "HaveKill", "=", "true", ";", "Kill", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_SRC", ":", "IndirectSrc", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "IndirectDst", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "V_INTERP_P1_F32", ":", "case", "AMDGPU", "::", "V_INTERP_P2_F32", ":", "case", "AMDGPU", "::", "V_INTERP_MOV_F32", ":", "NeedWQM", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "NeedWQM", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "getFirstNonPHI", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "expand_epilogue", "(", "void", ")", "{", "int", "size", ";", "register", "int", "regno", ";", "int", "return_size", ";", "rtx", "scratch", ";", "gcc_assert", "(", "reload_completed", "==", "1", ")", ";", "size", "=", "get_frame_size", "(", ")", ";", "if", "(", "current_function_return_rtx", "==", "0", ")", "return_size", "=", "0", ";", "else", "if", "(", "GET_CODE", "(", "current_function_return_rtx", ")", "==", "MEM", ")", "return_size", "=", "HARD_REG_SIZE", ";", "else", "return_size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "current_function_return_rtx", ")", ")", ";", "if", "(", "return_size", ">", "HARD_REG_SIZE", "&&", "return_size", "<=", "2", "*", "HARD_REG_SIZE", ")", "scratch", "=", "iy_reg", ";", "else", "scratch", "=", "ix_reg", ";", "for", "(", "regno", "=", "SOFT_REG_LAST", ";", "regno", ">=", "SOFT_REG_FIRST", ";", "regno", "--", ")", "{", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "{", "emit_move_after_reload", "(", "gen_rtx_REG", "(", "HImode", ",", "regno", ")", ",", "stack_pop_word", ",", "scratch", ")", ";", "}", "}", "if", "(", "TARGET_M6812", "&&", "(", "size", ">", "4", "||", "size", "==", "3", ")", ")", "{", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "}", "else", "if", "(", "(", "!", "optimize_size", "&&", "size", ">", "8", ")", "||", "(", "optimize_size", "&&", "size", ">", "10", ")", ")", "{", "rtx", "insn", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "HImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "}", "else", "{", "int", "i", ";", "for", "(", "i", "=", "2", ";", "i", "<=", "size", ";", "i", "+=", "2", ")", "emit_move_after_reload", "(", "scratch", ",", "stack_pop_word", ",", "scratch", ")", ";", "if", "(", "size", "&", "1", ")", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "const1_rtx", ")", ")", ";", "}", "if", "(", "current_function_interrupt", ")", "{", "emit_move_after_reload", "(", "gen_rtx_REG", "(", "HImode", ",", "SOFT_SAVED_XY_REGNUM", ")", ",", "stack_pop_word", ",", "scratch", ")", ";", "emit_move_after_reload", "(", "gen_rtx_REG", "(", "HImode", ",", "SOFT_Z_REGNUM", ")", ",", "stack_pop_word", ",", "scratch", ")", ";", "emit_move_after_reload", "(", "m68hc11_soft_tmp_reg", ",", "stack_pop_word", ",", "scratch", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_move_after_reload", "(", "hard_frame_pointer_rtx", ",", "stack_pop_word", ",", "scratch", ")", ";", "else", "if", "(", "current_function_trap", "&&", "return_size", "!=", "0", ")", "{", "rtx", "addr_reg", "=", "stack_pointer_rtx", ";", "if", "(", "!", "TARGET_M6812", ")", "{", "emit_move_after_reload", "(", "scratch", ",", "stack_pointer_rtx", ",", "0", ")", ";", "addr_reg", "=", "scratch", ";", "}", "emit_move_after_reload", "(", "gen_rtx_MEM", "(", "HImode", ",", "gen_rtx_PLUS", "(", "HImode", ",", "addr_reg", ",", "const1_rtx", ")", ")", ",", "d_reg", ",", "0", ")", ";", "if", "(", "return_size", ">", "HARD_REG_SIZE", ")", "emit_move_after_reload", "(", "gen_rtx_MEM", "(", "HImode", ",", "gen_rtx_PLUS", "(", "HImode", ",", "addr_reg", ",", "GEN_INT", "(", "3", ")", ")", ")", ",", "ix_reg", ",", "0", ")", ";", "}", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "epilogue", "into", "RTL", "." ]

[ "m68hc11", "1", "0", "0", "2", "4", "3", "8", "10", "2", "2", "2", "1", "0", "0", "0", "3", "0" ]

[]

[ "<s>", "bool", "function_checker", "::", "require_immediate", "(", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "min", ",", "HOST_WIDE_INT", "max", ")", "const", "{", "gcc_assert", "(", "argno", "<", "m_nargs", ")", ";", "tree", "arg", "=", "m_args", "[", "argno", "]", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", ")", "{", "report_non_ice", "(", "argno", ")", ";", "return", "false", ";", "}", "return", "require_immediate_range", "(", "argno", ",", "min", ",", "max", ")", ";", "}", "</s>" ]

[ "Check", "that", "argument", "ARGNO", "is", "an", "integer", "constant", "expression", "and", "store", "its", "value", "in", "VALUE_OUT", "if", "so", ".", "The", "caller", "should", "first", "check", "that", "argument", "ARGNO", "exists", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd", "(", "SDValue", "X", ",", "ConstantSDNode", "*", "XC", ",", "ConstantSDNode", "*", "CC", ",", "SDValue", "Y", ",", "unsigned", "OldShiftOpcode", ",", "unsigned", "NewShiftOpcode", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "XC", "&&", "OldShiftOpcode", "==", "ISD", "::", "SRL", "&&", "XC", "->", "isOne", "(", ")", ")", "return", "false", ";", "if", "(", "NewShiftOpcode", "==", "ISD", "::", "SRL", "&&", "CC", "->", "isOne", "(", ")", ")", "return", "true", ";", "return", "!", "XC", ";", "}", "</s>" ]

[ "Given", "the", "pattern", "(", "X", "&", "(", "C", "l", ">", ">", "/", "<", "<", "Y", ")", ")", "==/", "!", "=", "0", "return", "true", "if", "it", "should", "be", "transformed", "into", ":", "(", "(", "X", "<", "<", "/l", ">", ">", "Y", ")", "&", "C", ")", "==/", "!", "=", "0", "WARNING", ":", "if", "'", "X", "'", "is", "a", "constant", ",", "the", "fold", "may", "deadlock", "!", "FIXME", ":", "we", "could", "avoid", "passing", "XC", ",", "but", "we", "ca", "n't", "use", "isConstOrConstSplat", "(", ")", "here", "because", "it", "can", "end", "up", "being", "not", "linked", "in", "." ]

[ "RISCV", "RISCV", "ISD::SRL", "ISD::SRL" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enableMachinePipeliner", "(", ")", "const", "{", "return", "(", "CPUDirective", "==", "PPC", "::", "DIR_PWR9", ")", "&&", "EnableMachinePipeliner", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "MachinePipeliner", "." ]

[ "PowerPC", "PPC", "PPC::DIR_PWR9" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "true", ",", "&", "isARMArea3Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM::t2STMDB_UPD", "ARM::STMDB_UPD", "ARM::t2STR_PRE", "ARM::STR_PRE", "ARM::VSTMDDB_UPD", "ARM", "ARM", "0", "ARM" ]

[]

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

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

[ "frv", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", ".", "isABI_O32", "(", ")", ",", "Subtarget", ".", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "SystemZMCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SystemZ", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FK_390_PC12DBL\"", ",", "4", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC16DBL\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC24DBL\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC32DBL\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_TLS_CALL\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::NumTargetFixupKinds", "\"FK_390_PC12DBL\"", "4", "12", "\"FK_390_PC16DBL\"", "0", "16", "\"FK_390_PC24DBL\"", "0", "24", "\"FK_390_PC32DBL\"", "0", "32", "\"FK_390_TLS_CALL\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "alpha_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_FPREGS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "63", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "</s>" ]

[ "On", "the", "Alpha", ",", "we", "use", "this", "to", "disable", "the", "floating-point", "registers", "when", "they", "do", "n't", "exist", "." ]

[ "alpha", "32", "63", "1" ]

[]

[ "<s>", "void", "alpha_split_tmode_pair", "(", "rtx", "operands", "[", "4", "]", ",", "machine_mode", "mode", ",", "bool", "fixup_overlap", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "fixup_overlap", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "3", "]", ")", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "}", "</s>" ]

[ "Split", "a", "TImode", "or", "TFmode", "move", "from", "OP", "[", "1", "]", "to", "OP", "[", "0", "]", "into", "a", "pair", "of", "DImode", "moves", "from", "OP", "[", "2,3", "]", "to", "OP", "[", "0,1", "]", ".", "If", "FIXUP_OVERLAP", "is", "true", ",", "guarantee", "that", "the", "sequence", "set", "(", "OP", "[", "0", "]", "OP", "[", "2", "]", ")", "set", "(", "OP", "[", "1", "]", "OP", "[", "3", "]", ")", "is", "valid", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "." ]

[ "alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0", "0", "3", "0", "1", "2", "3" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isTailCall", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isBranch", "(", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "Op", ".", "isGlobal", "(", ")", "||", "Op", ".", "isSymbol", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determines", "whether", "Inst", "is", "a", "tail", "call", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "EVT", "ElemVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "Alignment", ">=", "ElemVT", ".", "getStoreSize", "(", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "begin", "(", ")", "const", "{", "return", "getStart", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "isStackIdSafeForLocalArea", "(", "unsigned", "StackId", ")", "const", "override", "{", "return", "StackId", "!=", "TargetStackID", "::", "SVEVector", ";", "}", "</s>" ]

[ "This", "method", "returns", "whether", "or", "not", "it", "is", "safe", "for", "an", "object", "with", "the", "given", "stack", "id", "to", "be", "bundled", "into", "the", "local", "area", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "OR1KAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "unsigned", "Kind", ";", "unsigned", "ErrorInfo", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "std", "::", "string", ">", ",", "4", ">", "MapAndConstraints", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Kind", ",", "Inst", ",", "MapAndConstraints", ",", "ErrorInfo", ",", "false", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"Instruction use requires option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"Unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"Too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "OR1KOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "IDLoc", ",", "\"Invalid operand for instruction\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "4", "\"Instruction use requires option to be enabled\"", "\"Unrecognized instruction mnemonic\"", "0U", "\"Too few operands for instruction\"", "OR1K", "\"Invalid operand for instruction\"", "\"Unknown match type detected!\"" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "WaitcntBrackets", "::", "merge", "(", "const", "WaitcntBrackets", "&", "Other", ")", "{", "bool", "StrictDom", "=", "false", ";", "VgprUB", "=", "std", "::", "max", "(", "VgprUB", ",", "Other", ".", "VgprUB", ")", ";", "SgprUB", "=", "std", "::", "max", "(", "SgprUB", ",", "Other", ".", "SgprUB", ")", ";", "for", "(", "auto", "T", ":", "inst_counter_types", "(", ")", ")", "{", "const", "bool", "OldOutOfOrder", "=", "counterOutOfOrder", "(", "T", ")", ";", "const", "unsigned", "OldEvents", "=", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "const", "unsigned", "OtherEvents", "=", "Other", ".", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "if", "(", "OtherEvents", "&", "~", "OldEvents", ")", "StrictDom", "=", "true", ";", "PendingEvents", "|=", "OtherEvents", ";", "const", "unsigned", "MyPending", "=", "ScoreUBs", "[", "T", "]", "-", "ScoreLBs", "[", "T", "]", ";", "const", "unsigned", "OtherPending", "=", "Other", ".", "ScoreUBs", "[", "T", "]", "-", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "const", "unsigned", "NewUB", "=", "ScoreLBs", "[", "T", "]", "+", "std", "::", "max", "(", "MyPending", ",", "OtherPending", ")", ";", "if", "(", "NewUB", "<", "ScoreLBs", "[", "T", "]", ")", "report_fatal_error", "(", "\"waitcnt score overflow\"", ")", ";", "MergeInfo", "M", ";", "M", ".", "OldLB", "=", "ScoreLBs", "[", "T", "]", ";", "M", ".", "OtherLB", "=", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "M", ".", "MyShift", "=", "NewUB", "-", "ScoreUBs", "[", "T", "]", ";", "M", ".", "OtherShift", "=", "NewUB", "-", "Other", ".", "ScoreUBs", "[", "T", "]", ";", "ScoreUBs", "[", "T", "]", "=", "NewUB", ";", "StrictDom", "|=", "mergeScore", "(", "M", ",", "LastFlat", "[", "T", "]", ",", "Other", ".", "LastFlat", "[", "T", "]", ")", ";", "bool", "RegStrictDom", "=", "false", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "VgprUB", ";", "J", "++", ")", "{", "RegStrictDom", "|=", "mergeScore", "(", "M", ",", "VgprScores", "[", "T", "]", "[", "J", "]", ",", "Other", ".", "VgprScores", "[", "T", "]", "[", "J", "]", ")", ";", "}", "if", "(", "T", "==", "VM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "VgprUB", ";", "J", "++", ")", "{", "unsigned", "char", "NewVmemTypes", "=", "VgprVmemTypes", "[", "J", "]", "|", "Other", ".", "VgprVmemTypes", "[", "J", "]", ";", "RegStrictDom", "|=", "NewVmemTypes", "!=", "VgprVmemTypes", "[", "J", "]", ";", "VgprVmemTypes", "[", "J", "]", "=", "NewVmemTypes", ";", "}", "}", "if", "(", "T", "==", "LGKM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ";", "J", "<=", "SgprUB", ";", "J", "++", ")", "{", "RegStrictDom", "|=", "mergeScore", "(", "M", ",", "SgprScores", "[", "J", "]", ",", "Other", ".", "SgprScores", "[", "J", "]", ")", ";", "}", "}", "if", "(", "RegStrictDom", "&&", "!", "OldOutOfOrder", ")", "StrictDom", "=", "true", ";", "}", "return", "StrictDom", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "AMDGPU", "\"waitcnt score overflow\"", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "hwloop_fail", "(", "hwloop_info", "loop", ")", "{", "rtx", "insn", ",", "test", ",", "testreg", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"splitting doloop insn %d\\n\"", ",", "INSN_UID", "(", "loop", "->", "loop_end", ")", ")", ";", "insn", "=", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ";", "if", "(", "loop", "->", "head", "==", "NULL", "||", "loop", "->", "iter_reg_used_outside", "||", "loop", "->", "iter_reg_used", "||", "TEST_HARD_REG_BIT", "(", "loop", "->", "regs_set_in_loop", ",", "REGNO", "(", "loop", "->", "iter_reg", ")", ")", "||", "loop", "->", "incoming_dest", "!=", "loop", "->", "head", "||", "EDGE_COUNT", "(", "loop", "->", "head", "->", "preds", ")", "!=", "2", ")", "emit_insn_before", "(", "insn", ",", "loop", "->", "loop_end", ")", ";", "else", "{", "rtx_insn", "*", "t", "=", "loop", "->", "start_label", ";", "while", "(", "!", "NOTE_P", "(", "t", ")", "||", "NOTE_KIND", "(", "t", ")", "!=", "NOTE_INSN_BASIC_BLOCK", ")", "t", "=", "NEXT_INSN", "(", "t", ")", ";", "emit_insn_after", "(", "insn", ",", "t", ")", ";", "}", "testreg", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "loop", "->", "loop_end", ")", ",", "0", ",", "2", ")", ")", ";", "if", "(", "GET_CODE", "(", "testreg", ")", "==", "SCRATCH", ")", "testreg", "=", "loop", "->", "iter_reg", ";", "else", "emit_insn_before", "(", "gen_movsi", "(", "testreg", ",", "loop", "->", "iter_reg", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "testreg", ",", "const0_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_cbranchsi4", "(", "test", ",", "testreg", ",", "const0_rtx", ",", "loop", "->", "start_label", ")", ",", "loop", "->", "loop_end", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "loop", "->", "start_label", ";", "LABEL_NUSES", "(", "loop", "->", "start_label", ")", "++", ";", "delete_insn", "(", "loop", "->", "loop_end", ")", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "when", "a", "loop", "we", "have", "discovered", "turns", "out", "not", "to", "be", "optimizable", ";", "we", "have", "to", "split", "the", "doloop_end", "pattern", "into", "a", "subtract", "and", "a", "test", "." ]

[ "c6x", "\"splitting doloop insn %d\\n\"", "2", "0", "2" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "Z80", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Z80", "Z80::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "initialize", "(", "MCContext", "&", "Context", ")", "{", "Ctx", "=", "&", "Context", ";", "usesSgprAt", "(", "SgprIndexUnusedMin", "=", "-", "1", ")", ";", "usesVgprAt", "(", "VgprIndexUnusedMin", "=", "-", "1", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "RISCVTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GPRRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "1", "0", "0U", "RISCV::GPRRegClass" ]

[]

[ "<s>", "bool", "GBZ80InstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected opcode!\"", ")", ";", "case", "GB", "::", "CALL_cc_nn", ":", "case", "GB", "::", "CALL_nn", ":", "case", "GB", "::", "JP_cc_nn", ":", "case", "GB", "::", "JP_nn", ":", "return", "true", ";", "case", "GB", "::", "JR_cc_e", ":", "case", "GB", "::", "JR_e", ":", "return", "BrOffset", ">=", "-", "127", "&&", "BrOffset", "<=", "129", ";", "}", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "GBZ80", "GB", "\"unexpected opcode!\"", "GB::CALL_cc_nn", "GB::CALL_nn", "GB::JP_cc_nn", "GB::JP_nn", "GB::JR_cc_e", "GB::JR_e", "127", "129" ]

[]

[ "<s>", "static", "tree", "arm_cxx_guard_type", "(", "void", ")", "{", "return", "TARGET_AAPCS_BASED", "?", "integer_type_node", ":", "long_long_integer_type_node", ";", "}", "</s>" ]

[ "The", "generic", "C++", "ABI", "says", "64-bit", "(", "long", "long", ")", ".", "The", "EABI", "says", "32-bit", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "SystemZRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the frame register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "\"What is the frame register\"", "0" ]

[]

[ "<s>", "void", "SIWholeQuadMode", "::", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "LiveMaskReg", ",", "bool", "isEntry", ")", "{", "auto", "BII", "=", "Blocks", ".", "find", "(", "&", "MBB", ")", ";", "if", "(", "BII", "==", "Blocks", ".", "end", "(", ")", ")", "return", ";", "const", "BlockInfo", "&", "BI", "=", "BII", "->", "second", ";", "if", "(", "!", "(", "BI", ".", "InNeeds", "&", "StateWQM", ")", ")", "return", ";", "if", "(", "!", "isEntry", "&&", "!", "(", "BI", ".", "Needs", "&", "StateExact", ")", "&&", "BI", ".", "OutNeeds", "!=", "StateExact", ")", "return", ";", "unsigned", "SavedWQMReg", "=", "0", ";", "bool", "WQMFromExec", "=", "isEntry", ";", "char", "State", "=", "isEntry", "?", "StateExact", ":", "StateWQM", ";", "auto", "II", "=", "MBB", ".", "getFirstNonPHI", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "II", "!=", "IE", ")", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "++", "II", ";", "if", "(", "TII", "->", "isScalarUnit", "(", "MI", ")", "&&", "!", "MI", ".", "isTerminator", "(", ")", ")", "continue", ";", "if", "(", "TargetInstrInfo", "::", "isGenericOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "MI", ".", "getNumExplicitOperands", "(", ")", ">=", "1", ")", "{", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "TRI", "->", "isSGPRReg", "(", "*", "MRI", ",", "Op", ".", "getReg", "(", ")", ")", ")", "{", "continue", ";", "}", "}", "}", "}", "char", "Needs", "=", "0", ";", "char", "OutNeeds", "=", "0", ";", "auto", "InstrInfoIt", "=", "Instructions", ".", "find", "(", "&", "MI", ")", ";", "if", "(", "InstrInfoIt", "!=", "Instructions", ".", "end", "(", ")", ")", "{", "Needs", "=", "InstrInfoIt", "->", "second", ".", "Needs", ";", "OutNeeds", "=", "InstrInfoIt", "->", "second", ".", "OutNeeds", ";", "if", "(", "OutNeeds", "==", "StateExact", "&&", "MI", ".", "isTerminator", "(", ")", ")", "{", "assert", "(", "Needs", "==", "0", ")", ";", "Needs", "=", "StateExact", ";", "}", "}", "if", "(", "Needs", "&&", "State", "!=", "Needs", ")", "{", "if", "(", "Needs", "==", "StateExact", ")", "{", "assert", "(", "!", "SavedWQMReg", ")", ";", "if", "(", "!", "WQMFromExec", "&&", "(", "OutNeeds", "&", "StateWQM", ")", ")", "SavedWQMReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "toExact", "(", "MBB", ",", "&", "MI", ",", "SavedWQMReg", ",", "LiveMaskReg", ")", ";", "}", "else", "{", "assert", "(", "WQMFromExec", "==", "(", "SavedWQMReg", "==", "0", ")", ")", ";", "toWQM", "(", "MBB", ",", "&", "MI", ",", "SavedWQMReg", ")", ";", "SavedWQMReg", "=", "0", ";", "}", "State", "=", "Needs", ";", "}", "}", "if", "(", "(", "BI", ".", "OutNeeds", "&", "StateWQM", ")", "&&", "State", "!=", "StateWQM", ")", "{", "assert", "(", "WQMFromExec", "==", "(", "SavedWQMReg", "==", "0", ")", ")", ";", "toWQM", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "SavedWQMReg", ")", ";", "}", "else", "if", "(", "BI", ".", "OutNeeds", "==", "StateExact", "&&", "State", "!=", "StateExact", ")", "{", "toExact", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "0", ",", "LiveMaskReg", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "1", "0", "0", "0", "0", "AMDGPU::SReg_64RegClass", "0", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssembly" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableDeadRegisterElimination", ")", "addPass", "(", "createAArch64DeadRegisterDefinitions", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

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

[]

[ "<s>", "static", "bool", "mips_interrupt_extra_call_saved_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "(", "ISA_HAS_HILO", "||", "TARGET_DSP", ")", "&&", "MD_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_DSP", "&&", "DSP_ACC_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "cfun", "->", "machine", "->", "use_shadow_register_set", "==", "SHADOW_SET_NO", ")", "{", "if", "(", "regno", "==", "GP_REG_FIRST", ")", "return", "false", ";", "if", "(", "KERNEL_REG_P", "(", "regno", ")", ")", "return", "false", ";", "if", "(", "regno", "==", "STACK_POINTER_REGNUM", ")", "return", "false", ";", "return", "call_used_regs", "[", "regno", "]", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "is", "a", "register", "that", "is", "ordinarily", "call-clobbered", "but", "must", "nevertheless", "be", "preserved", "by", "an", "interrupt", "handler", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64PostSelectOptimize", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

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

[]

[ "<s>", "bool", "function_checker", "::", "require_immediate", "(", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "&", "value_out", ")", "{", "gcc_assert", "(", "argno", "<", "m_nargs", ")", ";", "tree", "arg", "=", "m_args", "[", "argno", "]", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", ")", "{", "report_non_ice", "(", "location", ",", "fndecl", ",", "argno", ")", ";", "return", "false", ";", "}", "value_out", "=", "tree_to_uhwi", "(", "arg", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "that", "argument", "ARGNO", "is", "an", "integer", "constant", "expression", "and", "store", "its", "value", "in", "VALUE_OUT", "if", "so", ".", "The", "caller", "should", "first", "check", "that", "argument", "ARGNO", "exists", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ix86_expand_copysign", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "op0", ",", "op1", ",", "mask", ",", "nmask", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "op1", "=", "operands", "[", "2", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "mode", "==", "SFmode", "?", "V4SFmode", ":", "V2DFmode", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "CONST_DOUBLE", ")", "{", "rtvec", "v", ";", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op0", ")", ")", ")", "op0", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op0", ",", "mode", ")", ";", "if", "(", "op0", "==", "CONST0_RTX", "(", "mode", ")", ")", "op0", "=", "CONST0_RTX", "(", "vmode", ")", ";", "else", "{", "if", "(", "mode", "==", "SFmode", ")", "v", "=", "gen_rtvec", "(", "4", ",", "op0", ",", "CONST0_RTX", "(", "SFmode", ")", ",", "CONST0_RTX", "(", "SFmode", ")", ",", "CONST0_RTX", "(", "SFmode", ")", ")", ";", "else", "v", "=", "gen_rtvec", "(", "2", ",", "op0", ",", "CONST0_RTX", "(", "DFmode", ")", ")", ";", "op0", "=", "force_reg", "(", "vmode", ",", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "v", ")", ")", ";", "}", "mask", "=", "ix86_build_signbit_mask", "(", "mode", ",", "0", ",", "0", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "emit_insn", "(", "gen_copysignsf3_const", "(", "dest", ",", "op0", ",", "op1", ",", "mask", ")", ")", ";", "else", "emit_insn", "(", "gen_copysigndf3_const", "(", "dest", ",", "op0", ",", "op1", ",", "mask", ")", ")", ";", "}", "else", "{", "nmask", "=", "ix86_build_signbit_mask", "(", "mode", ",", "0", ",", "1", ")", ";", "mask", "=", "ix86_build_signbit_mask", "(", "mode", ",", "0", ",", "0", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "emit_insn", "(", "gen_copysignsf3_var", "(", "dest", ",", "NULL", ",", "op0", ",", "op1", ",", "nmask", ",", "mask", ")", ")", ";", "else", "emit_insn", "(", "gen_copysigndf3_var", "(", "dest", ",", "NULL", ",", "op0", ",", "op1", ",", "nmask", ",", "mask", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "copysign", "operation", ".", "Special", "case", "operand", "0", "being", "a", "constant", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "aarch64_sve_pred_valid_immediate", "(", "rtx", "x", ",", "simd_immediate_info", "*", "info", ")", "{", "if", "(", "aarch64_sve_ptrue_svpattern_p", "(", "x", ",", "info", ")", ")", "return", "true", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "{", "if", "(", "info", ")", "*", "info", "=", "simd_immediate_info", "(", "DImode", ",", "0", ")", ";", "return", "true", ";", "}", "rtx_vector_builder", "builder", ";", "if", "(", "!", "aarch64_get_sve_pred_bits", "(", "builder", ",", "x", ")", ")", "return", "false", ";", "unsigned", "int", "elt_size", "=", "aarch64_widest_sve_pred_elt_size", "(", "builder", ")", ";", "if", "(", "int", "vl", "=", "aarch64_partial_ptrue_length", "(", "builder", ",", "elt_size", ")", ")", "{", "machine_mode", "mode", "=", "aarch64_sve_pred_mode", "(", "elt_size", ")", ".", "require", "(", ")", ";", "aarch64_svpattern", "pattern", "=", "aarch64_svpattern_for_vl", "(", "mode", ",", "vl", ")", ";", "if", "(", "pattern", "!=", "AARCH64_NUM_SVPATTERNS", ")", "{", "if", "(", "info", ")", "{", "scalar_int_mode", "int_mode", "=", "aarch64_sve_element_int_mode", "(", "mode", ")", ";", "*", "info", "=", "simd_immediate_info", "(", "int_mode", ",", "pattern", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "SVE", "predicate", ".", "If", "INFO", "is", "nonnull", ",", "use", "it", "to", "describe", "valid", "immediates", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasUnwantedEffectsWhenEXECEmpty", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "isSMRD", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SENDMSG", "||", "Opcode", "==", "AMDGPU", "::", "S_SENDMSGHALT", "||", "Opcode", "==", "AMDGPU", "::", "EXP", "||", "Opcode", "==", "AMDGPU", "::", "EXP_DONE", "||", "Opcode", "==", "AMDGPU", "::", "DS_ORDERED_COUNT", ")", "return", "true", ";", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_READLANE_B32", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "we", "must", "prevent", "this", "instruction", "from", "executing", "with", "EXEC", "=", "0", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SENDMSG", "AMDGPU::S_SENDMSGHALT", "AMDGPU::EXP", "AMDGPU::EXP_DONE", "AMDGPU::DS_ORDERED_COUNT", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::V_READLANE_B32" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "ENDPGM", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "ISD::OutputArg", "AMDGPUISD::ENDPGM", "MVT::Other" ]

[]

[ "<s>", "void", "MCS51InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MCS51MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "MCS51MachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "MCS51", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "MCS51", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "0", "MVT::i8", "MCS51::STDPtrQRr", "MVT::i16", "MCS51::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "static", "void", "mips_sim_wait_units", "(", "struct", "mips_sim", "*", "state", ",", "rtx", "insn", ")", "{", "state_t", "tmp_state", ";", "tmp_state", "=", "alloca", "(", "state_size", "(", ")", ")", ";", "while", "(", "state", "->", "insns_left", "==", "0", "||", "(", "memcpy", "(", "tmp_state", ",", "state", "->", "dfa_state", ",", "state_size", "(", ")", ")", ",", "state_transition", "(", "tmp_state", ",", "insn", ")", ">=", "0", ")", ")", "mips_sim_next_cycle", "(", "state", ")", ";", "}", "</s>" ]

[ "Advance", "simulation", "state", "STATE", "until", "the", "units", "required", "by", "instruction", "INSN", "are", "available", "." ]

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

[]

[ "<s>", "static", "HOST_WIDE_INT", "rs6000_disable_incompatible_switches", "(", "void", ")", "{", "HOST_WIDE_INT", "ignore_masks", "=", "rs6000_isa_flags_explicit", ";", "size_t", "i", ",", "j", ";", "static", "const", "struct", "{", "const", "HOST_WIDE_INT", "no_flag", ";", "const", "HOST_WIDE_INT", "dep_flags", ";", "const", "char", "*", "const", "name", ";", "}", "flags", "[", "]", "=", "{", "{", "OPTION_MASK_POWER10", ",", "OTHER_POWER10_MASKS", ",", "\"power10\"", "}", ",", "{", "OPTION_MASK_P9_VECTOR", ",", "OTHER_P9_VECTOR_MASKS", ",", "\"power9-vector\"", "}", ",", "{", "OPTION_MASK_P8_VECTOR", ",", "OTHER_P8_VECTOR_MASKS", ",", "\"power8-vector\"", "}", ",", "{", "OPTION_MASK_VSX", ",", "OTHER_VSX_VECTOR_MASKS", ",", "\"vsx\"", "}", ",", "{", "OPTION_MASK_ALTIVEC", ",", "OTHER_ALTIVEC_MASKS", ",", "\"altivec\"", "}", ",", "}", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "flags", ")", ";", "i", "++", ")", "{", "HOST_WIDE_INT", "no_flag", "=", "flags", "[", "i", "]", ".", "no_flag", ";", "if", "(", "(", "rs6000_isa_flags", "&", "no_flag", ")", "==", "0", "&&", "(", "rs6000_isa_flags_explicit", "&", "no_flag", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "dep_flags", "=", "flags", "[", "i", "]", ".", "dep_flags", ";", "HOST_WIDE_INT", "set_flags", "=", "(", "rs6000_isa_flags_explicit", "&", "rs6000_isa_flags", "&", "dep_flags", ")", ";", "if", "(", "set_flags", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "ARRAY_SIZE", "(", "rs6000_opt_masks", ")", ";", "j", "++", ")", "if", "(", "(", "set_flags", "&", "rs6000_opt_masks", "[", "j", "]", ".", "mask", ")", "!=", "0", ")", "{", "set_flags", "&=", "~", "rs6000_opt_masks", "[", "j", "]", ".", "mask", ";", "error", "(", "\"%<-mno-%s%> turns off %<-m%s%>\"", ",", "flags", "[", "i", "]", ".", "name", ",", "rs6000_opt_masks", "[", "j", "]", ".", "name", ")", ";", "}", "gcc_assert", "(", "!", "set_flags", ")", ";", "}", "rs6000_isa_flags", "&=", "~", "dep_flags", ";", "ignore_masks", "|=", "no_flag", "|", "dep_flags", ";", "}", "}", "return", "ignore_masks", ";", "}", "</s>" ]

[ "If", "the", "user", "used", "-mno-vsx", ",", "we", "need", "turn", "off", "all", "of", "the", "implicit", "ISA", "2.06", ",", "2.07", ",", "and", "3.0", "options", "that", "relate", "to", "the", "vector", "unit", "(", "-mdirect-move", ",", "-mupper-regs-df", ",", "etc.", ")", ".", "If", "the", "user", "used", "-mno-power8-vector", ",", "we", "need", "to", "turn", "off", "all", "of", "the", "implicit", "ISA", "2.07", "and", "3.0", "options", "that", "relate", "to", "the", "vector", "unit", ".", "If", "the", "user", "used", "-mno-power9-vector", ",", "we", "need", "to", "turn", "off", "all", "of", "the", "implicit", "ISA", "3.0", "options", "that", "relate", "to", "the", "vector", "unit", ".", "This", "function", "does", "not", "handle", "explicit", "options", "such", "as", "the", "user", "specifying", "-mdirect-move", ".", "These", "are", "handled", "in", "rs6000_option_override_internal", ",", "and", "the", "appropriate", "error", "is", "given", "if", "needed", ".", "We", "return", "a", "mask", "of", "all", "of", "the", "implicit", "options", "that", "should", "not", "be", "enabled", "by", "default", "." ]

[ "rs6000", "\"power10\"", "\"power9-vector\"", "\"power8-vector\"", "\"vsx\"", "\"altivec\"", "0", "0", "0", "0", "0", "\"%<-mno-%s%> turns off %<-m%s%>\"" ]

[]

[ "<s>", "bool", "TL45TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "return", "TargetLoweringBase", "::", "shouldReduceLoadWidth", "(", "Load", ",", "ExtTy", ",", "NewVT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "TL45", "TL45", "ISD::LoadExtType" ]

[]

[ "<s>", "static", "void", "ia64_option_override", "(", "void", ")", "{", "unsigned", "int", "i", ";", "cl_deferred_option", "*", "opt", ";", "vec", "<", "cl_deferred_option", ">", "*", "v", "=", "(", "vec", "<", "cl_deferred_option", ">", "*", ")", "ia64_deferred_options", ";", "if", "(", "v", ")", "FOR_EACH_VEC_ELT", "(", "*", "v", ",", "i", ",", "opt", ")", "{", "switch", "(", "opt", "->", "opt_index", ")", "{", "case", "OPT_mfixed_range_", ":", "fix_range", "(", "opt", "->", "arg", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "TARGET_AUTO_PIC", ")", "target_flags", "|=", "MASK_CONST_GP", ";", "if", "(", "optimize", ">=", "3", ")", "flag_ira_loop_pressure", "=", "1", ";", "ia64_section_threshold", "=", "(", "OPTION_SET_P", "(", "g_switch_value", ")", "?", "g_switch_value", ":", "IA64_DEFAULT_GVALUE", ")", ";", "init_machine_status", "=", "ia64_init_machine_status", ";", "if", "(", "flag_align_functions", "&&", "!", "str_align_functions", ")", "str_align_functions", "=", "\"64\"", ";", "if", "(", "flag_align_loops", "&&", "!", "str_align_loops", ")", "str_align_loops", "=", "\"32\"", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "flag_no_common", "=", "1", ";", "ia64_override_options_after_change", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "ia64", "3", "1", "\"64\"", "\"32\"", "1" ]

[]

[ "<s>", "int", "ConvergingVLIWScheduler", "::", "SchedulingCost", "(", "ReadyQueue", "&", "Q", ",", "SUnit", "*", "SU", ",", "SchedCandidate", "&", "Candidate", ",", "RegPressureDelta", "&", "Delta", ",", "bool", "verbose", ")", "{", "int", "ResCount", "=", "1", ";", "if", "(", "!", "SU", "||", "SU", "->", "isScheduled", ")", "return", "ResCount", ";", "if", "(", "SU", "->", "isScheduleHigh", ")", "ResCount", "+=", "PriorityOne", ";", "if", "(", "Q", ".", "getID", "(", ")", "==", "TopQID", ")", "{", "ResCount", "+=", "(", "SU", "->", "getHeight", "(", ")", "*", "ScaleTwo", ")", ";", "if", "(", "Top", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ")", ")", "ResCount", "<<=", "FactorOne", ";", "}", "else", "{", "ResCount", "+=", "(", "SU", "->", "getDepth", "(", ")", "*", "ScaleTwo", ")", ";", "if", "(", "Bot", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ")", ")", "ResCount", "<<=", "FactorOne", ";", "}", "unsigned", "NumNodesBlocking", "=", "0", ";", "if", "(", "Q", ".", "getID", "(", ")", "==", "TopQID", ")", "{", "for", "(", "SUnit", "::", "const_succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "getSingleUnscheduledPred", "(", "I", "->", "getSUnit", "(", ")", ")", "==", "SU", ")", "++", "NumNodesBlocking", ";", "}", "else", "{", "for", "(", "SUnit", "::", "const_pred_iterator", "I", "=", "SU", "->", "Preds", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Preds", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "getSingleUnscheduledSucc", "(", "I", "->", "getSUnit", "(", ")", ")", "==", "SU", ")", "++", "NumNodesBlocking", ";", "}", "ResCount", "+=", "(", "NumNodesBlocking", "*", "ScaleTwo", ")", ";", "ResCount", "-=", "(", "Delta", ".", "Excess", ".", "UnitIncrease", "*", "PriorityThree", ")", ";", "ResCount", "-=", "(", "Delta", ".", "CriticalMax", ".", "UnitIncrease", "*", "PriorityThree", ")", ";", "DEBUG", "(", "if", "(", "verbose", ")", "dbgs", "(", ")", "<<", "\" Total(\"", "<<", "ResCount", "<<", "\")\"", ")", ";", "return", "ResCount", ";", "}", "</s>" ]

[ "Single", "point", "to", "compute", "overall", "scheduling", "cost", "." ]

[ "Hexagon", "1", "0", "\" Total(\"", "\")\"" ]

[]

[ "<s>", "static", "void", "mips_sim_finish_insn", "(", "struct", "mips_sim", "*", "state", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", ")", "mips_sim_issue_nop", "(", "state", ")", ";", "switch", "(", "GET_CODE", "(", "SEQ_BEGIN", "(", "insn", ")", ")", ")", "{", "case", "CODE_LABEL", ":", "case", "CALL_INSN", ":", "mips_sim_reset", "(", "state", ")", ";", "break", ";", "case", "JUMP_INSN", ":", "if", "(", "INSN_ANNULLED_BRANCH_P", "(", "SEQ_BEGIN", "(", "insn", ")", ")", ")", "mips_sim_reset", "(", "state", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Update", "simulation", "state", "STATE", "so", "that", "it", "'s", "ready", "to", "accept", "the", "instruction", "after", "INSN", ".", "INSN", "should", "be", "part", "of", "the", "main", "rtl", "chain", ",", "not", "a", "member", "of", "a", "SEQUENCE", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "aarch64_gimple_fold_builtin", "(", "gimple_stmt_iterator", "*", "gsi", ")", "{", "gcall", "*", "stmt", "=", "as_a", "<", "gcall", "*", ">", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "tree", "fndecl", "=", "gimple_call_fndecl", "(", "stmt", ")", ";", "unsigned", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "unsigned", "int", "subcode", "=", "code", ">>", "AARCH64_BUILTIN_SHIFT", ";", "gimple", "*", "new_stmt", "=", "NULL", ";", "switch", "(", "code", "&", "AARCH64_BUILTIN_CLASS", ")", "{", "case", "AARCH64_BUILTIN_GENERAL", ":", "new_stmt", "=", "aarch64_general_gimple_fold_builtin", "(", "subcode", ",", "stmt", ")", ";", "break", ";", "case", "AARCH64_BUILTIN_SVE", ":", "new_stmt", "=", "aarch64_sve", "::", "gimple_fold_builtin", "(", "subcode", ",", "gsi", ",", "stmt", ")", ";", "break", ";", "}", "if", "(", "!", "new_stmt", ")", "return", "false", ";", "gsi_replace", "(", "gsi", ",", "new_stmt", ",", "true", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLE_FOLD_BUILTIN", "." ]

[ "aarch64", "aarch64_sve::gimple_fold_builtin" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be spilled\"", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "SrcReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be spilled\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]