Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", ";", "}", "unsigned", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "Paired", "==", "0", ")", "return", ";", "unsigned", "PairedPhys", "=", "0", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "is_contained", "(", "Order", ",", "PairedPhys", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "unsigned", "Reg", ":", "Order", ")", "{", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "unsigned", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "sh_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "if", "(", "TARGET_ELF", ")", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "TEXT_SECTION_ASM_OP", ")", ";", "else", "switch_to_section", "(", "data_section", ")", ";", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "fputs", "(", "\"\\t.little\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "the", "start", "of", "the", "assembler", "file", "." ]

[ "sh", "\"%s\\n\"", "\"\\t.little\\n\"" ]

[]

[ "<s>", "void", "TVMInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TVM", "::", "TO_TUPLE_COPY_S", ":", "case", "TVM", "::", "TO_SLICE_COPY_S", ":", "case", "TVM", "::", "TO_BUILDER_COPY_S", ":", "case", "TVM", "::", "TO_CELL_COPY_S", ":", "case", "TVM", "::", "FROM_TUPLE_COPY_S", ":", "case", "TVM", "::", "FROM_SLICE_COPY_S", ":", "case", "TVM", "::", "FROM_BUILDER_COPY_S", ":", "case", "TVM", "::", "FROM_CELL_COPY_S", ":", "case", "TVM", "::", "REG_TO_REG_COPY_S", ":", "case", "TVM", "::", "PUSH_GLOBAL_ADDRESS_S", ":", "case", "TVM", "::", "FALLTHROUGH_RETURN", ":", "return", ";", "default", ":", "break", ";", "}", "{", "std", "::", "string", "Str", ";", "raw_string_ostream", "OStr", "(", "Str", ")", ";", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OStr", ")", ")", "printInstruction", "(", "MI", ",", "OStr", ")", ";", "OStr", ".", "flush", "(", ")", ";", "assert", "(", "Str", ".", "front", "(", ")", "==", "'\\t'", ")", ";", "Str", ".", "erase", "(", "0", ",", "1", ")", ";", "O", "<<", "Str", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "TVM", "TVM", "TVM::TO_TUPLE_COPY_S", "TVM::TO_SLICE_COPY_S", "TVM::TO_BUILDER_COPY_S", "TVM::TO_CELL_COPY_S", "TVM::FROM_TUPLE_COPY_S", "TVM::FROM_SLICE_COPY_S", "TVM::FROM_BUILDER_COPY_S", "TVM::FROM_CELL_COPY_S", "TVM::REG_TO_REG_COPY_S", "TVM::PUSH_GLOBAL_ADDRESS_S", "TVM::FALLTHROUGH_RETURN", "0", "1" ]

[]

[ "<s>", "int", "mips_idiv_insns", "(", "void", ")", "{", "int", "count", ";", "count", "=", "1", ";", "if", "(", "TARGET_CHECK_ZERO_DIV", ")", "{", "if", "(", "GENERATE_DIVIDE_TRAPS", ")", "count", "++", ";", "else", "count", "+=", "2", ";", "}", "if", "(", "TARGET_FIX_R4000", "||", "TARGET_FIX_R4400", ")", "count", "++", ";", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "for", "an", "integer", "division", "." ]

[ "mips", "1", "2" ]

[]

[ "<s>", "static", "bool", "frv_for_each_packet", "(", "void", "(", "*", "handle_packet", ")", "(", "void", ")", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next_insn", ";", "frv_packet", ".", "issue_rate", "=", "frv_issue_rate", "(", ")", ";", "if", "(", "!", "optimize", "||", "!", "flag_schedule_insns_after_reload", "||", "!", "TARGET_VLIW_BRANCH", "||", "frv_packet", ".", "issue_rate", "==", "1", ")", "return", "false", ";", "dfa_start", "(", ")", ";", "frv_packet", ".", "dfa_state", "=", "alloca", "(", "state_size", "(", ")", ")", ";", "frv_start_packet_block", "(", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "0", ";", "insn", "=", "next_insn", ")", "{", "enum", "rtx_code", "code", ";", "bool", "eh_insn_p", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "next_insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "code", "==", "CODE_LABEL", ")", "{", "frv_finish_packet", "(", "handle_packet", ")", ";", "frv_start_packet_block", "(", ")", ";", "}", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", ")", "{", "case", "USE", ":", "case", "CLOBBER", ":", "break", ";", "default", ":", "if", "(", "CALL_P", "(", "insn", ")", "&&", "frv_cpu_type", "==", "FRV_CPU_TOMCAT", ")", "frv_finish_packet", "(", "handle_packet", ")", ";", "eh_insn_p", "=", "(", "find_reg_note", "(", "insn", ",", "REG_EH_REGION", ",", "NULL", ")", "!=", "NULL", ")", ";", "if", "(", "eh_insn_p", "&&", "!", "frv_issues_to_branch_unit_p", "(", "insn", ")", ")", "frv_finish_packet", "(", "handle_packet", ")", ";", "if", "(", "!", "frv_pack_insn_p", "(", "insn", ")", ")", "{", "frv_finish_packet", "(", "handle_packet", ")", ";", "while", "(", "!", "frv_pack_insn_p", "(", "insn", ")", ")", "state_transition", "(", "frv_packet", ".", "dfa_state", ",", "0", ")", ";", "}", "frv_add_insn_to_packet", "(", "insn", ")", ";", "if", "(", "code", "==", "CALL_INSN", "||", "code", "==", "JUMP_INSN", "||", "eh_insn_p", ")", "frv_finish_packet", "(", "handle_packet", ")", ";", "break", ";", "}", "}", "frv_finish_packet", "(", "handle_packet", ")", ";", "dfa_finish", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "If", "packing", "is", "enabled", ",", "divide", "the", "instructions", "into", "packets", "and", "return", "true", ".", "Call", "HANDLE_PACKET", "for", "each", "complete", "packet", "." ]

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

[]

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

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

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

[]

[ "<s>", "bool", "AArch64SIMDInstrOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "AArch64InstrInfo", "*", "AAII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "AAII", ")", "return", "false", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "AAII", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "OptimizationKind", ":", "{", "VectorElem", ",", "Interleave", "}", ")", "{", "if", "(", "!", "shouldExitEarly", "(", "&", "MF", ",", "OptimizationKind", ")", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "8", ">", "RemoveMIs", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", ".", "begin", "(", ")", ",", "MIE", "=", "MBB", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "bool", "InstRewrite", ";", "if", "(", "OptimizationKind", "==", "VectorElem", ")", "InstRewrite", "=", "optimizeVectElement", "(", "MI", ")", ";", "else", "InstRewrite", "=", "optimizeLdStInterleave", "(", "MI", ")", ";", "if", "(", "InstRewrite", ")", "{", "RemoveMIs", ".", "push_back", "(", "&", "MI", ")", ";", "Changed", "=", "true", ";", "}", "++", "MII", ";", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "RemoveMIs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "static", "void", "c6x_clear_sched_context", "(", "void", "*", "_sc", ")", "{", "c6x_sched_context_t", "sc", "=", "(", "c6x_sched_context_t", ")", "_sc", ";", "gcc_assert", "(", "_sc", "!=", "NULL", ")", ";", "free", "(", "sc", "->", "prev_cycle_state_ctx", ")", ";", "}", "</s>" ]

[ "Clear", "data", "in", "_SC", "." ]

[ "c6x" ]

[]

[ "<s>", "Relocator", "::", "Result", "unsupported", "(", "Relocation", "&", "pReloc", ",", "AArch64Relocator", "&", "pParent", ")", "{", "return", "Relocator", "::", "Unsupported", ";", "}", "</s>" ]

[ "The", "instruction", "is", "unsupported", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "Sched", "::", "Preference", "ARMTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "unsigned", "NumVals", "=", "N", "->", "getNumValues", "(", ")", ";", "if", "(", "!", "NumVals", ")", "return", "Sched", "::", "RegPressure", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumVals", ";", "++", "i", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "i", ")", ";", "if", "(", "VT", "==", "MVT", "::", "Glue", "||", "VT", "==", "MVT", "::", "Other", ")", "continue", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "||", "VT", ".", "isVector", "(", ")", ")", "return", "Sched", "::", "Latency", ";", "}", "if", "(", "!", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "Sched", "::", "RegPressure", ";", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", "->", "get", "(", "N", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "MCID", ".", "getNumDefs", "(", ")", "==", "0", ")", "return", "Sched", "::", "RegPressure", ";", "if", "(", "!", "Itins", "->", "isEmpty", "(", ")", "&&", "Itins", "->", "getOperandCycle", "(", "MCID", ".", "getSchedClass", "(", ")", ",", "0", ")", ">", "2", ")", "return", "Sched", "::", "Latency", ";", "return", "Sched", "::", "RegPressure", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "MVT::Glue", "MVT::Other", "0", "0", "2" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "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", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

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

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCyles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "void", "dimode_scalar_chain", "::", "replace_with_subreg_in_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "rtx", "new_reg", ")", "{", "replace_with_subreg", "(", "single_set", "(", "insn", ")", ",", "reg", ",", "new_reg", ")", ";", "}", "</s>" ]

[ "Replace", "REG", "in", "INSN", "with", "a", "V2DI", "subreg", "of", "NEW_REG", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "EnablePEVectorSpills", "||", "MFI", ".", "hasCalls", "(", ")", "||", "!", "Subtarget", ".", "hasP9Vector", "(", ")", ")", "return", "false", ";", "BitVector", "BVAllocatable", "=", "TRI", "->", "getAllocatableSet", "(", "MF", ")", ";", "BitVector", "BVCalleeSaved", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "CSRegs", "[", "i", "]", ";", "++", "i", ")", "BVCalleeSaved", ".", "set", "(", "CSRegs", "[", "i", "]", ")", ";", "for", "(", "unsigned", "Reg", ":", "BVAllocatable", ".", "set_bits", "(", ")", ")", "{", "if", "(", "BVCalleeSaved", "[", "Reg", "]", "||", "(", "!", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "PPC", "::", "VFRCRegClass", ".", "contains", "(", "Reg", ")", ")", "||", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "Reg", ")", ")", ")", "BVAllocatable", ".", "reset", "(", "Reg", ")", ";", "}", "bool", "AllSpilledToReg", "=", "true", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "if", "(", "BVAllocatable", ".", "none", "(", ")", ")", "return", "false", ";", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "if", "(", "!", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "AllSpilledToReg", "=", "false", ";", "continue", ";", "}", "unsigned", "VolatileVFReg", "=", "BVAllocatable", ".", "find_first", "(", ")", ";", "if", "(", "VolatileVFReg", "<", "BVAllocatable", ".", "size", "(", ")", ")", "{", "CS", ".", "setDstReg", "(", "VolatileVFReg", ")", ";", "BVAllocatable", ".", "reset", "(", "VolatileVFReg", ")", ";", "}", "else", "{", "AllSpilledToReg", "=", "false", ";", "}", "}", "return", "AllSpilledToReg", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "PowerPC", "PPC", "PPC", "0", "PPC::F8RCRegClass", "PPC::VFRCRegClass", "PPC::G8RCRegClass", "PPC::GPRCRegClass" ]

[]

[ "<s>", "void", "i386_pe_assemble_visibility", "(", "tree", "decl", ",", "int", ")", "{", "if", "(", "!", "decl", "||", "!", "lookup_attribute", "(", "\"visibility\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", ";", "if", "(", "!", "DECL_ARTIFICIAL", "(", "decl", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"visibility attribute not supported \"", "\"in this configuration; ignored\"", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assembler", "directive", "to", "set", "symbol", "for", "DECL", "visibility", "to", "the", "visibility", "type", "VIS", ",", "which", "must", "not", "be", "VISIBILITY_DEFAULT", ".", "As", "for", "PE", "there", "is", "no", "hidden", "support", "in", "gas", ",", "we", "just", "warn", "for", "user-specified", "visibility", "attributes", "." ]

[ "i386", "\"visibility\"", "\"visibility attribute not supported \"", "\"in this configuration; ignored\"" ]

[]

[ "<s>", "static", "void", "union_uses", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "df_ref", "def", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "while", "(", "link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_out", "=", "1", ";", "if", "(", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "{", "rtx", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "(", "void", ")", "unionfind_union", "(", "insn_entry", "+", "INSN_UID", "(", "insn", ")", ",", "insn_entry", "+", "INSN_UID", "(", "use_insn", ")", ")", ";", "}", "link", "=", "link", "->", "next", ";", "}", "}", "</s>" ]

[ "Union", "INSN", "with", "all", "insns", "containing", "uses", "reached", "from", "DEF", ".", "Detect", "whether", "DEF", "is", "live-out", "from", "the", "current", "function", "." ]

[ "powerpcspe", "1", "1" ]

[]

[ "<s>", "int", "mips_const_insns", "(", "rtx", "x", ")", "{", "struct", "mips_integer_op", "codes", "[", "MIPS_MAX_INTEGER_OPS", "]", ";", "enum", "mips_symbol_type", "symbol_type", ";", "rtx", "offset", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "HIGH", ":", "if", "(", "!", "mips_symbolic_constant_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "symbol_type", ")", "||", "!", "mips_split_p", "[", "symbol_type", "]", ")", "return", "0", ";", "return", "TARGET_MIPS16", "?", "4", ":", "1", ";", "case", "CONST_INT", ":", "if", "(", "TARGET_MIPS16", ")", "return", "(", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "255", ")", "?", "1", ":", "SMALL_OPERAND_UNSIGNED", "(", "INTVAL", "(", "x", ")", ")", "?", "2", ":", "IN_RANGE", "(", "-", "INTVAL", "(", "x", ")", ",", "0", ",", "255", ")", "?", "2", ":", "SMALL_OPERAND_UNSIGNED", "(", "-", "INTVAL", "(", "x", ")", ")", "?", "3", ":", "0", ")", ";", "return", "mips_build_integer", "(", "codes", ",", "INTVAL", "(", "x", ")", ")", ";", "case", "CONST_DOUBLE", ":", "case", "CONST_VECTOR", ":", "return", "!", "TARGET_MIPS16", "&&", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "?", "1", ":", "0", ";", "case", "CONST", ":", "if", "(", "CONST_GP_P", "(", "x", ")", ")", "return", "1", ";", "if", "(", "mips_symbolic_constant_p", "(", "x", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "symbol_type", ")", ")", "return", "mips_symbol_insns", "(", "symbol_type", ",", "MAX_MACHINE_MODE", ")", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "int", "n", "=", "mips_const_insns", "(", "x", ")", ";", "if", "(", "n", "!=", "0", ")", "{", "if", "(", "SMALL_INT", "(", "offset", ")", ")", "return", "n", "+", "1", ";", "else", "if", "(", "!", "targetm", ".", "cannot_force_const_mem", "(", "GET_MODE", "(", "x", ")", ",", "x", ")", ")", "return", "n", "+", "1", "+", "mips_build_integer", "(", "codes", ",", "INTVAL", "(", "offset", ")", ")", ";", "}", "}", "return", "0", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "mips_symbol_insns", "(", "mips_classify_symbol", "(", "x", ",", "SYMBOL_CONTEXT_LEA", ")", ",", "MAX_MACHINE_MODE", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Likewise", "for", "constant", "X", "." ]

[ "mips", "0", "0", "4", "1", "0", "255", "1", "2", "0", "255", "2", "3", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", ")", "{", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "Mips", "Mips", "Mips::RetRA" ]

[]

[ "<s>", "void", "SNESInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "SNES", "::", "LDRdPtr", ":", "case", "SNES", "::", "LDRdPtrPi", ":", "case", "SNES", "::", "LDRdPtrPd", ":", "O", "<<", "\"\\tld\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "if", "(", "Opcode", "==", "SNES", "::", "LDRdPtrPd", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "SNES", "::", "LDRdPtrPi", ")", "O", "<<", "'+'", ";", "break", ";", "case", "SNES", "::", "STPtrRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "break", ";", "case", "SNES", "::", "STPtrPiRr", ":", "case", "SNES", "::", "STPtrPdRr", ":", "O", "<<", "\"\\tst\\t\"", ";", "if", "(", "Opcode", "==", "SNES", "::", "STPtrPdRr", ")", "O", "<<", "'-'", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "if", "(", "Opcode", "==", "SNES", "::", "STPtrPiRr", ")", "O", "<<", "'+'", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "2", ",", "O", ")", ";", "break", ";", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "SNES", "SNES", "SNES::LDRdPtr", "SNES::LDRdPtrPi", "SNES::LDRdPtrPd", "\"\\tld\\t\"", "0", "\", \"", "SNES::LDRdPtrPd", "1", "SNES::LDRdPtrPi", "SNES::STPtrRr", "\"\\tst\\t\"", "0", "\", \"", "1", "SNES::STPtrPiRr", "SNES::STPtrPdRr", "\"\\tst\\t\"", "SNES::STPtrPdRr", "1", "SNES::STPtrPiRr", "\", \"", "2" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "GetMemOperand", "(", "MBB", ",", "FI", ",", "MachineMemOperand", "::", "MOStore", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Mips", "::", "SwRxSpImmX16", ";", "assert", "(", "Opc", "&&", "\"Register class not handled!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::CPU16RegsRegClass", "Mips::SwRxSpImmX16", "\"Register class not handled!\"", "0" ]

[]

[ "<s>", "static", "void", "pdp11_option_override", "(", "void", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "{", "targetm", ".", "asm_out", ".", "open_paren", "=", "\"<\"", ";", "targetm", ".", "asm_out", ".", "close_paren", "=", "\">\"", ";", "}", "}", "</s>" ]

[ "This", "overrides", "some", "target", "hooks", "that", "are", "initializer", "elements", "so", "they", "ca", "n't", "be", "variables", "in", "the", "#", "define", "." ]

[ "pdp11", "\"<\"", "\">\"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "bool", "IsLocal", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "if", "(", "IsLocal", ")", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "}", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported code model for lowering\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "{", "SDValue", "AddrHi", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_HI", ")", ";", "SDValue", "AddrLo", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "RISCVII", "::", "MO_LO", ")", ";", "SDValue", "MNHi", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "LUI", ",", "DL", ",", "Ty", ",", "AddrHi", ")", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "ADDI", ",", "DL", ",", "Ty", ",", "MNHi", ",", "AddrLo", ")", ",", "0", ")", ";", "}", "case", "CodeModel", "::", "Medium", ":", "{", "SDValue", "Addr", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "0", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "RISCV", "::", "PseudoLLA", ",", "DL", ",", "Ty", ",", "Addr", ")", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Return", "the", "address", "accessed", "by", "this", "recipe", "." ]

[ "RI5CY", "RISCV", "0", "RISCV::PseudoLLA", "0", "RISCV::PseudoLA", "0", "\"Unsupported code model for lowering\"", "RISCVII::MO_HI", "RISCVII::MO_LO", "RISCV::LUI", "0", "RISCV::ADDI", "0", "0", "RISCV::PseudoLLA", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "MSP430FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "*", "MF", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FP", ",", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FP", ",", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "MSP430", "::", "R12", ",", "MSP430", "::", "R13", ",", "MSP430", "::", "R14", ",", "MSP430", "::", "R15", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5", ",", "MSP430", "::", "R6", ",", "MSP430", "::", "R7", ",", "MSP430", "::", "R8", ",", "MSP430", "::", "R9", ",", "MSP430", "::", "R10", ",", "MSP430", "::", "R11", ",", "MSP430", "::", "R12", ",", "MSP430", "::", "R13", ",", "MSP430", "::", "R14", ",", "MSP430", "::", "R15", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430::FP", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "0", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "0", "MSP430::FP", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "MSP430::R12", "MSP430::R13", "MSP430::R14", "MSP430::R15", "0", "MSP430::R5", "MSP430::R6", "MSP430::R7", "MSP430::R8", "MSP430::R9", "MSP430::R10", "MSP430::R11", "MSP430::R12", "MSP430::R13", "MSP430::R14", "MSP430::R15", "0", "MSP430", "MSP430" ]

[]

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

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

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

[]

[ "<s>", "bool", "P2AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"=== Parse Instruction ===\\n\"", ")", ";", "size_t", "start", "=", "0", ",", "next", "=", "Name", ".", "find", "(", "'\\t'", ")", ";", "StringRef", "inst", "=", "Name", ".", "slice", "(", "start", ",", "next", ")", ";", "StringRef", "condition", ";", "if", "(", "cond_strings", ".", "find", "(", "inst", ")", "!=", "cond_strings", ".", "end", "(", ")", ")", "{", "start", "=", "next", ";", "next", "=", "Name", ".", "find", "(", "' '", ")", ";", "condition", "=", "inst", ";", "inst", "=", "Name", ".", "slice", "(", "start", ",", "next", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"inst: \"", "<<", "inst", "<<", "\"\\n\"", ")", ";", "Operands", ".", "push_back", "(", "P2Operand", "::", "CreateToken", "(", "inst", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"haven't found the end of the statement\\n\"", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"=== End Parse Instruction ===\\n\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "P2", "P2", "\"=== Parse Instruction ===\\n\"", "0", "\"inst: \"", "\"\\n\"", "P2Operand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"haven't found the end of the statement\\n\"", "\"unexpected token in argument list\"", "\"=== End Parse Instruction ===\\n\"" ]

[]

[ "<s>", "bool", "X86RetpolineThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "Is64Bit", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "Module", "&", "M", "=", "const_cast", "<", "Module", "&", ">", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "ThunkNamePrefix", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "useRetpoline", "(", ")", "||", "STI", "->", "useRetpolineExternalThunk", "(", ")", ")", "return", "false", ";", "if", "(", "Is64Bit", ")", "createThunkFunction", "(", "M", ",", "R11ThunkName", ")", ";", "else", "for", "(", "StringRef", "Name", ":", "{", "EAXThunkName", ",", "ECXThunkName", ",", "EDXThunkName", ",", "EDIThunkName", "}", ")", "createThunkFunction", "(", "M", ",", "Name", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "\"__llvm_retpoline_r11\"", "&&", "\"Should only have an r11 thunk on 64-bit targets\"", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDIThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDI", ")", ";", "else", "llvm_unreachable", "(", "\"Invalid thunk name on x86-32!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"__llvm_retpoline_r11\"", "\"Should only have an r11 thunk on 64-bit targets\"", "X86::R11", "X86::EAX", "X86::ECX", "X86::EDX", "X86::EDI", "\"Invalid thunk name on x86-32!\"" ]

[]

[ "<s>", "bool", "constant_address_p", "(", "rtx", "x", ")", "{", "return", "CONSTANT_P", "(", "x", ")", "&&", "ix86_legitimate_address_p", "(", "Pmode", ",", "x", ",", "1", ")", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", "address", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "if", "(", "!", "MI", "->", "hasPostISelHook", "(", ")", ")", "{", "assert", "(", "!", "convertAddSubFlagsOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"", ")", ";", "return", ";", "}", "const", "MCInstrDesc", "*", "MCID", "=", "&", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "NewOpc", "=", "convertAddSubFlagsOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NewOpc", ")", "{", "const", "ARMBaseInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "MCID", "=", "&", "TII", "->", "get", "(", "NewOpc", ")", ";", "assert", "(", "MCID", "->", "getNumOperands", "(", ")", "==", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "+", "1", "&&", "\"converted opcode should be the same except for cc_out\"", ")", ";", "MI", "->", "setDesc", "(", "*", "MCID", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "0", ",", "true", ")", ")", ";", "}", "unsigned", "ccOutIdx", "=", "MCID", "->", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "!", "MI", "->", "hasOptionalDef", "(", ")", "||", "!", "MCID", "->", "OpInfo", "[", "ccOutIdx", "]", ".", "isOptionalDef", "(", ")", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "bool", "definesCPSR", "=", "false", ";", "bool", "deadCPSR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "MCID", "->", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "{", "definesCPSR", "=", "true", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "deadCPSR", "=", "true", ";", "MI", "->", "RemoveOperand", "(", "i", ")", ";", "break", ";", "}", "}", "if", "(", "!", "definesCPSR", ")", "{", "assert", "(", "!", "NewOpc", "&&", "\"Optional cc_out operand required\"", ")", ";", "return", ";", "}", "assert", "(", "deadCPSR", "==", "!", "Node", "->", "hasAnyUseOfValue", "(", "1", ")", "&&", "\"inconsistent dead flag\"", ")", ";", "if", "(", "deadCPSR", ")", "{", "assert", "(", "!", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ".", "getReg", "(", ")", "&&", "\"expect uninitialized optional cc_out operand\"", ")", ";", "return", ";", "}", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "ccOutIdx", ")", ";", "MO", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";", "MO", ".", "setIsDef", "(", "true", ")", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "ARM", "ARM", "\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"", "ARM", "ARM", "1", "\"converted opcode should be the same except for cc_out\"", "0", "1", "\"Optional cc_out operand required\"", "ARM::CPSR", "\"Optional cc_out operand required\"", "1", "\"inconsistent dead flag\"", "\"expect uninitialized optional cc_out operand\"", "ARM::CPSR" ]

[]

[ "<s>", "void", "NyuziRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFL", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "stackSize", "=", "alignTo", "(", "MFI", ".", "getStackSize", "(", ")", ",", "TFL", ".", "getStackAlignment", "(", ")", ")", ";", "int64_t", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "stackSize", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "if", "(", "FrameIndex", ">=", "MinCSFI", "&&", "FrameIndex", "<=", "MaxCSFI", ")", "FrameReg", "=", "Nyuzi", "::", "SP_REG", ";", "else", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "isInt", "<", "14", ">", "(", "Offset", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "isInt", "<", "25", ">", "(", "Offset", ")", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MBBI", "->", "getParent", "(", ")", ";", "const", "NyuziInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "NyuziInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "Nyuzi", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Nyuzi", "::", "MOVEHI", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addImm", "(", "(", "Offset", ">>", "13", ")", "&", "0x7ffff", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Nyuzi", "::", "ADDISSS", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addReg", "(", "Reg", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ",", "false", ",", "true", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "&", "0x1fff", ")", ";", "}", "else", "report_fatal_error", "(", "\"frame index out of bounds: frame too large\"", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "0", "\"Unexpected\"", "1", "0", "1", "0", "1", "Nyuzi::SP_REG", "14", "1", "25", "Nyuzi", "Nyuzi", "Nyuzi::GPR32RegClass", "Nyuzi::MOVEHI", "13", "0x7ffff", "Nyuzi::ADDISSS", "1", "0x1fff", "\"frame index out of bounds: frame too large\"" ]

[]

[ "<s>", "void", "rs6000_xcoff_declare_function_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "char", "*", "buffer", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "name", ")", "+", "1", ")", ";", "char", "*", "p", ";", "int", "dollar_inside", "=", "0", ";", "struct", "declare_alias_data", "data", "=", "{", "file", ",", "false", "}", ";", "strcpy", "(", "buffer", ",", "name", ")", ";", "p", "=", "strchr", "(", "buffer", ",", "'$'", ")", ";", "while", "(", "p", ")", "{", "*", "p", "=", "'_'", ";", "dollar_inside", "++", ";", "p", "=", "strchr", "(", "p", "+", "1", ",", "'$'", ")", ";", "}", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "{", "if", "(", "!", "RS6000_WEAK", "||", "!", "DECL_WEAK", "(", "decl", ")", ")", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.globl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "rs6000_xcoff_visibility", "(", "decl", ")", ",", "file", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "else", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.lglobl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "fputs", "(", "\"\\t.csect \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\n\"", ":", "\",3\\n\"", ",", "file", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "buffer", ")", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long .\"", ":", "\"\\t.llong .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\", TOC[tc0], 0\\n\"", ",", "file", ")", ";", "in_section", "=", "NULL", ";", "switch_to_section", "(", "function_section", "(", "decl", ")", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "buffer", ")", ";", "data", ".", "function_descriptor", "=", "true", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "if", "(", "!", "DECL_IGNORED_P", "(", "decl", ")", ")", "{", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "xcoffout_declare_function", "(", "file", ",", "decl", ",", "buffer", ")", ";", "else", "if", "(", "dwarf_debuginfo_p", "(", ")", ")", "{", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.function .%s,.%s,2,0\\n\"", ",", "name", ",", "name", ")", ";", "}", "}", "return", ";", "}", "</s>" ]

[ "This", "macro", "produces", "the", "initial", "definition", "of", "a", "function", "name", ".", "On", "the", "RS/6000", ",", "we", "need", "to", "place", "an", "extra", "'", ".", "'", "in", "the", "function", "name", "and", "output", "the", "function", "descriptor", ".", "Dollar", "signs", "are", "converted", "to", "underscores", ".", "The", "csect", "for", "the", "function", "will", "have", "already", "been", "created", "when", "text_section", "was", "selected", ".", "We", "do", "have", "to", "go", "back", "to", "that", "csect", ",", "however", ".", "The", "third", "and", "fourth", "parameters", "to", "the", ".function", "pseudo-op", "(", "16", "and", "044", ")", "are", "placeholders", "which", "no", "longer", "have", "any", "use", ".", "Because", "AIX", "assembler", "'s", ".set", "command", "has", "unexpected", "semantics", ",", "we", "output", "all", "aliases", "as", "alternative", "labels", "in", "front", "of", "the", "definition", "." ]

[ "rs6000", "1", "0", "1", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.globl .\"", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.lglobl .\"", "\"\\t.csect \"", "\"\\n\"", "\",3\\n\"", "\"\\t.long .\"", "\"\\t.llong .\"", "\", TOC[tc0], 0\\n\"", "\"\\t.function .%s,.%s,2,0\\n\"" ]

[]

[ "<s>", "static", "void", "restore_saved_cr", "(", "rtx", "reg", ",", "int", "using_mfcr_multiple", ",", "bool", "exit_func", ")", "{", "int", "count", "=", "0", ";", "int", "i", ";", "if", "(", "using_mfcr_multiple", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "count", "++", ";", "gcc_assert", "(", "count", ")", ";", "}", "if", "(", "using_mfcr_multiple", "&&", "count", ">", "1", ")", "{", "rtx_insn", "*", "insn", ";", "rtvec", "p", ";", "int", "ndx", ";", "p", "=", "rtvec_alloc", "(", "count", ")", ";", "ndx", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtvec", "r", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "r", ",", "0", ")", "=", "reg", ";", "RTVEC_ELT", "(", "r", ",", "1", ")", "=", "GEN_INT", "(", "1", "<<", "(", "7", "-", "i", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "ndx", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "gen_rtx_UNSPEC", "(", "CCmode", ",", "r", ",", "UNSPEC_MOVESI_TO_CR", ")", ")", ";", "ndx", "++", ";", "}", "insn", "=", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "gcc_assert", "(", "ndx", "==", "count", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "else", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtx", "insn", "=", "emit_insn", "(", "gen_movsi_to_cr_one", "(", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "reg", ")", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "!=", "ABI_ELFv2", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "flag_shrink_wrap", ")", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "cr", "=", "gen_rtx_REG", "(", "SImode", ",", "CR2_REGNO", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "cr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Reload", "CR", "from", "REG", "." ]

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedVGPRs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedVGPRs", ",", "RS", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SavedVGPRs", ".", "clearBitsNotInMask", "(", "TRI", "->", "getAllVGPRRegMask", "(", ")", ")", ";", "const", "bool", "WillHaveFP", "=", "FrameInfo", ".", "hasCalls", "(", ")", "&&", "(", "SavedVGPRs", ".", "any", "(", ")", "||", "!", "allStackObjectsAreDead", "(", "FrameInfo", ")", ")", ";", "for", "(", "auto", "SSpill", ":", "MFI", "->", "getSGPRSpillVGPRs", "(", ")", ")", "SavedVGPRs", ".", "reset", "(", "SSpill", ".", "VGPR", ")", ";", "const", "bool", "HasFP", "=", "WillHaveFP", "||", "hasFP", "(", "MF", ")", ";", "if", "(", "!", "HasFP", ")", "return", ";", "if", "(", "MFI", "->", "haveFreeLanesForSGPRSpill", "(", "MF", ",", "1", ")", ")", "{", "int", "NewFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "4", ",", "4", ",", "true", ",", "nullptr", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "!", "MFI", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "NewFI", ")", ")", "llvm_unreachable", "(", "\"allocate SGPR spill should have worked\"", ")", ";", "MFI", "->", "FramePointerSaveIndex", "=", "NewFI", ";", "LLVM_DEBUG", "(", "auto", "Spill", "=", "MFI", "->", "getSGPRToVGPRSpills", "(", "NewFI", ")", ".", "front", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Spilling FP to \"", "<<", "printReg", "(", "Spill", ".", "VGPR", ",", "TRI", ")", "<<", "':'", "<<", "Spill", ".", "Lane", "<<", "'\\n'", ")", ";", "return", ";", "}", "MFI", "->", "SGPRForFPSaveRestoreCopy", "=", "findUnusedSGPRNonCalleeSaved", "(", "MF", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "MFI", "->", "SGPRForFPSaveRestoreCopy", ")", "{", "int", "NewFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "4", ",", "4", ",", "true", ",", "nullptr", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "!", "MFI", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "NewFI", ")", ")", "llvm_unreachable", "(", "\"allocate SGPR spill should have worked\"", ")", ";", "MFI", "->", "FramePointerSaveIndex", "=", "NewFI", ";", "LLVM_DEBUG", "(", "auto", "Spill", "=", "MFI", "->", "getSGPRToVGPRSpills", "(", "NewFI", ")", ".", "front", "(", ")", ";", "dbgs", "(", ")", "<<", "\"FP requires fallback spill to \"", "<<", "printReg", "(", "Spill", ".", "VGPR", ",", "TRI", ")", "<<", "':'", "<<", "Spill", ".", "Lane", "<<", "'\\n'", ";", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Saving FP with copy to \"", "<<", "printReg", "(", "MFI", "->", "SGPRForFPSaveRestoreCopy", ",", "TRI", ")", "<<", "'\\n'", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "4", "4", "\"allocate SGPR spill should have worked\"", "\"Spilling FP to \"", "4", "4", "\"allocate SGPR spill should have worked\"", "\"FP requires fallback spill to \"", "\"Saving FP with copy to \"" ]

[]

[ "<s>", "void", "add_vundef_operand", "(", "machine_mode", "mode", ")", "{", "add_input_operand", "(", "RVV_VUNDEF", "(", "mode", ")", ",", "mode", ")", ";", "}", "</s>" ]

[ "Since", "we", "may", "normalize", "vop/vop_tu/vop_m/vop_tumu", "..", "into", "a", "single", "patter", ".", "We", "add", "a", "undef", "for", "the", "intrinsics", "that", "do", "n't", "need", "a", "real", "merge", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "8", "\"Invalid register size\"", "AVR::POPRd" ]

[]

[ "<s>", "bool", "MipsNaClRewritePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "SandboxLoadsInBlock", "(", "MBB", ")", ";", "Modified", "|=", "SandboxStoresInBlock", "(", "MBB", ")", ";", "Modified", "|=", "SandboxBranchesInBlock", "(", "MBB", ")", ";", "Modified", "|=", "SandboxStackChangesInBlock", "(", "MBB", ")", ";", "}", "AlignAllJumpTargets", "(", "MF", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "HOST_WIDE_INT", "mips_debugger_offset", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "offset2", "=", "const0_rtx", ";", "rtx", "reg", "=", "eliminate_constant_term", "(", "addr", ",", "&", "offset2", ")", ";", "if", "(", "offset", "==", "0", ")", "offset", "=", "INTVAL", "(", "offset2", ")", ";", "if", "(", "reg", "==", "stack_pointer_rtx", "||", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "hard_frame_pointer_rtx", ")", "{", "offset", "-=", "cfun", "->", "machine", "->", "frame", ".", "total_size", ";", "if", "(", "reg", "==", "hard_frame_pointer_rtx", ")", "offset", "+=", "cfun", "->", "machine", "->", "frame", ".", "hard_frame_pointer_offset", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "The", "MIPS", "debug", "format", "wants", "all", "automatic", "variables", "and", "arguments", "to", "be", "in", "terms", "of", "the", "virtual", "frame", "pointer", "(", "stack", "pointer", "before", "any", "adjustment", "in", "the", "function", ")", ",", "while", "the", "MIPS", "3.0", "linker", "wants", "the", "frame", "pointer", "to", "be", "the", "stack", "pointer", "after", "the", "initial", "adjustment", ".", "So", ",", "we", "do", "the", "adjustment", "here", ".", "The", "arg", "pointer", "(", "which", "is", "eliminated", ")", "points", "to", "the", "virtual", "frame", "pointer", ",", "while", "the", "frame", "pointer", "(", "which", "may", "be", "eliminated", ")", "points", "to", "the", "stack", "pointer", "after", "the", "initial", "adjustments", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ",", "bool", "AllowI1", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "DL", ",", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "X86ScalarSSEf64", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "X86ScalarSSEf32", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f80", ")", "return", "false", ";", "return", "(", "AllowI1", "&&", "VT", "==", "MVT", "::", "i1", ")", "||", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "X86", "X86", "MVT::Other", "MVT::f64", "X86", "MVT::f32", "X86", "MVT::f80", "MVT::i1" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "&", "Op", "=", "static_cast", "<", "ARMOperand", "&", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ModImm", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", ".", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "evaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "min", "(", ")", "&&", "Value", "<=", "std", "::", "numeric_limits", "<", "uint32_t", ">", "::", "max", "(", ")", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_rGPR", ":", "if", "(", "hasV8Ops", "(", ")", "&&", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "Match_Success", ";", "return", "Match_rGPR", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "\"expression value must be representable in 32 bits\"", "ARM::SP", "ARM::GPRRegClassID" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", ".", "hasQPX", "(", ")", "&&", "Size", ">=", "32", "&&", "(", "!", "IsMemset", "||", "Size", ">=", "64", ")", "&&", "(", "!", "SrcAlign", "||", "SrcAlign", ">=", "32", ")", "&&", "(", "!", "DstAlign", "||", "DstAlign", ">=", "32", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "return", "MVT", "::", "v4f64", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Size", ">=", "16", "&&", "(", "(", "(", "!", "SrcAlign", "||", "SrcAlign", ">=", "16", ")", "&&", "(", "!", "DstAlign", "||", "DstAlign", ">=", "16", ")", ")", "||", "(", "(", "IsMemset", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "Subtarget", ".", "hasP8Vector", "(", ")", ")", ")", ")", "return", "MVT", "::", "v4i32", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "PowerPC", "PPC", "32", "64", "32", "32", "MVT::v4f64", "16", "16", "16", "MVT::v4i32", "PPC", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasMips32", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

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

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "IsaInfo", "::", "hasCodeObjectV3", "(", "getGlobalSTI", "(", ")", ")", ")", "{", "std", "::", "string", "ExpectedTarget", ";", "raw_string_ostream", "ExpectedTargetOS", "(", "ExpectedTarget", ")", ";", "IsaInfo", "::", "streamIsaVersion", "(", "getGlobalSTI", "(", ")", ",", "ExpectedTargetOS", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitDirectiveAMDGCNTarget", "(", "ExpectedTarget", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "&&", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDPAL", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "HSAMetadataStream", "->", "begin", "(", "M", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", "getTargetStreamer", "(", ")", "->", "getPALMetadata", "(", ")", "->", "readFromIR", "(", "M", ")", ";", "if", "(", "IsaInfo", "::", "hasCodeObjectV3", "(", "getGlobalSTI", "(", ")", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectVersion", "(", "2", ",", "1", ")", ";", "IsaVersion", "Version", "=", "getIsaVersion", "(", "getGlobalSTI", "(", ")", "->", "getCPU", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectISA", "(", "Version", ".", "Major", ",", "Version", ".", "Minor", ",", "Version", ".", "Stepping", ",", "\"AMD\"", ",", "\"AMDGPU\"", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU", "2", "1", "\"AMD\"", "\"AMDGPU\"" ]

[]

[ "<s>", "static", "bool", "reg_used_in_mem_p", "(", "int", "regno", ",", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "code", "==", "MEM", ")", "{", "if", "(", "refers_to_regno_p", "(", "regno", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "code", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "x", ")", ")", "==", "PC", ")", "{", "if", "(", "refers_to_regno_p", "(", "regno", ",", "SET_SRC", "(", "x", ")", ")", ")", "return", "true", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "reg_used_in_mem_p", "(", "regno", ",", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "x", ",", "i", ")", ";", "j", "++", ")", "if", "(", "reg_used_in_mem_p", "(", "regno", ",", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "register", "REGNO", "is", "used", "for", "forming", "a", "memory", "address", "in", "expression", "X", "." ]

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

[]

[ "<s>", "bool", "mips_dangerous_for_la25_p", "(", "rtx", "x", ")", "{", "HOST_WIDE_INT", "offset", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "return", "false", ";", "mips_split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "return", "global_got_operand", "(", "x", ",", "VOIDmode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "should", "not", "be", "moved", "directly", "into", "register", "$", "25", ".", "We", "need", "this", "because", "many", "versions", "of", "GAS", "will", "treat", "``", "la", "$", "25", ",", "foo", "''", "as", "part", "of", "a", "call", "sequence", "and", "so", "allow", "a", "global", "``", "foo", "''", "to", "be", "lazily", "bound", "." ]

[ "mips" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "AVR", "::", "GPR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVRdRr", ";", "}", "else", "if", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVWRdRr", ";", "}", "else", "if", "(", "SrcReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPREAD", ";", "}", "else", "if", "(", "DestReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPWRITE", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::GPR8RegClass", "AVR::MOVRdRr", "AVR::DREGSRegClass", "AVR::MOVWRdRr", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPREAD", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPWRITE", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "const", "TargetInstrInfo", "&", "TII", ")", "{", "unsigned", "Opc", ";", "uint64_t", "Chunk", ";", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "if", "(", "Offset", ">=", "(", "1LL", "<<", "15", ")", "-", "1", ")", "{", "Opc", "=", "SystemZ", "::", "ADD64ri32", ";", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "}", "else", "{", "Opc", "=", "SystemZ", "::", "ADD64ri16", ";", "Chunk", "=", "(", "1LL", "<<", "15", ")", "-", "1", ";", "}", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "SystemZ", "::", "R15D", ")", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ".", "addImm", "(", "(", "isSub", "?", "-", "(", "int64_t", ")", "ThisVal", ":", "ThisVal", ")", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "SystemZ", "0", "1LL", "15", "1", "SystemZ::ADD64ri32", "1LL", "31", "1", "SystemZ::ADD64ri16", "1LL", "15", "1", "SystemZ::R15D", "SystemZ::R15D", "3" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "bool", "HasCall", "=", "false", ";", "InstructionCost", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "NumStores", "+=", "getMemoryOpCost", "(", "Instruction", "::", "Store", ",", "MemAccessTy", ",", "None", ",", "0", ",", "TTI", "::", "TCK_RecipThroughput", ")", ";", "}", "}", "unsigned", "const", "NumStoresVal", "=", "*", "NumStores", ".", "getValue", "(", ")", ";", "unsigned", "const", "Max", "=", "(", "NumStoresVal", "?", "(", "12", "/", "NumStoresVal", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "0", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "LanaiFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</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", ")", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "sparc_can_use_return_insn_p", "(", "void", ")", "{", "return", "sparc_prologue_data_valid_p", "&&", "sparc_n_global_fp_regs", "==", "0", "&&", "TARGET_FLAT", "?", "(", "sparc_frame_size", "==", "0", "&&", "!", "sparc_save_local_in_regs_p", ")", ":", "(", "sparc_frame_size", "==", "0", "||", "!", "sparc_leaf_function_p", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "appropriate", "to", "emit", "`", "return", "'", "instructions", "in", "the", "body", "of", "a", "function", "." ]

[ "sparc", "0", "0", "0" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildDefaultInstruction", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "Opcode", ",", "unsigned", "DstReg", ",", "unsigned", "Src0Reg", ",", "unsigned", "Src1Reg", ")", "const", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Src0Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "-", "1", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addReg", "(", "Src1Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "-", "1", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "AMDGPU", "::", "PRED_SEL_OFF", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "buildDefaultInstruction", "-", "This", "function", "returns", "a", "MachineInstr", "with", "all", "the", "instruction", "modifiers", "initialized", "to", "their", "default", "values", "." ]

[ "R600", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "unsigned", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", ")", "adjustStackPointer", "(", "Amount", ",", "IsDestroy", ",", "MF", ",", "MBB", ",", "TII", ",", "I", ",", "DL", ")", ";", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</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", ")", "." ]

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

[]

[ "<s>", "static", "tree", "rs6000_builtin_mask_for_load", "(", "void", ")", "{", "if", "(", "(", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "||", "(", "TARGET_VSX", "&&", "!", "TARGET_EFFICIENT_UNALIGNED_VSX", ")", ")", "return", "altivec_builtin_mask_for_load", ";", "else", "return", "0", ";", "}", "</s>" ]

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

[ "rs6000", "0" ]

[]

[ "<s>", "static", "Value", "*", "getNumElements", "(", "BasicBlock", "*", "Preheader", ",", "Value", "*", "BTC", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "Preheader", ")", "{", "if", "(", "I", ".", "getOpcode", "(", ")", "!=", "Instruction", "::", "Add", "||", "&", "I", "!=", "BTC", ")", "continue", ";", "ConstantInt", "*", "MinusOne", "=", "nullptr", ";", "if", "(", "!", "(", "MinusOne", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "I", ".", "getOperand", "(", "1", ")", ")", ")", ")", "continue", ";", "if", "(", "MinusOne", "->", "getSExtValue", "(", ")", "==", "-", "1", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM TP: Found num elems: \"", "<<", "I", "<<", "\"\\n\"", ")", ";", "return", "I", ".", "getOperand", "(", "0", ")", ";", "}", "}", "IRBuilder", "<", ">", "Builder", "(", "Preheader", "->", "getTerminator", "(", ")", ")", ";", "Value", "*", "NumElements", "=", "Builder", ".", "CreateAdd", "(", "BTC", ",", "ConstantInt", "::", "get", "(", "BTC", "->", "getType", "(", ")", ",", "1", ")", ",", "\"num.elements\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM TP: Created num elems: \"", "<<", "*", "NumElements", "<<", "\"\\n\"", ")", ";", "return", "NumElements", ";", "}", "</s>" ]

[ "Random", "access", "to", "the", "elements", "." ]

[ "ARM", "1", "1", "\"ARM TP: Found num elems: \"", "\"\\n\"", "0", "1", "\"num.elements\"", "\"ARM TP: Created num elems: \"", "\"\\n\"" ]

[]

[ "<s>", "IndexType", "start", "(", ")", "const", "{", "return", "first", ";", "}", "</s>" ]

[ "start", "-", "Beginning", "of", "the", "overlapping", "interval", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "ix86_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "next_cum", ";", "tree", "fntype", ";", "gcc_assert", "(", "!", "no_rtl", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "next_cum", "=", "*", "cum", ";", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "ix86_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "cum", "->", "call_abi", "==", "MS_ABI", ")", "setup_incoming_varargs_ms_64", "(", "&", "next_cum", ")", ";", "else", "setup_incoming_varargs_64", "(", "&", "next_cum", ")", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "bool", "arc_is_uncached_mem_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "tree", "addr", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "addr", "=", "MEM_EXPR", "(", "pat", ")", ";", "if", "(", "!", "addr", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", "||", "TREE_CODE", "(", "addr", ")", "==", "VAR_DECL", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "addr", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "1", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "while", "(", "handled_component_p", "(", "addr", ")", ")", "{", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "COMPONENT_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "addr", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "1", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "addr", "=", "TREE_OPERAND", "(", "addr", ",", "0", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "PAT", "is", "a", "memory", "addressing", "an", "uncached", "data", "." ]

[ "arc", "\"uncached\"", "0", "\"uncached\"", "1", "\"uncached\"", "\"uncached\"", "0", "\"uncached\"", "1", "\"uncached\"", "0" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "BFI", ":", "return", "PerformBFICombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVRRD", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVDRR", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "PerformInsertEltCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ARMISD", "::", "VDUPLANE", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "PerformSELECT_CCCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ARMISD", "::", "VLD2DUP", ":", "case", "ARMISD", "::", "VLD3DUP", ":", "case", "ARMISD", "::", "VLD4DUP", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::OR", "ISD::AND", "ARMISD::BFI", "ARMISD::VMOVRRD", "ARMISD::VMOVDRR", "ISD::STORE", "ISD::BUILD_VECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::VECTOR_SHUFFLE", "ARMISD::VDUPLANE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SELECT_CC", "ARMISD::VLD2DUP", "ARMISD::VLD3DUP", "ARMISD::VLD4DUP", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vld2lane", "Intrinsic::arm_neon_vld3lane", "Intrinsic::arm_neon_vld4lane", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "Intrinsic::arm_neon_vst2lane", "Intrinsic::arm_neon_vst3lane", "Intrinsic::arm_neon_vst4lane" ]

[]

[ "<s>", "static", "bool", "allocate_stack_space", "(", "rtx", "size", ",", "HOST_WIDE_INT", "last_probe_offset", ",", "rtx", "temp_reg", ")", "{", "bool", "temp_reg_clobbered_p", "=", "false", ";", "HOST_WIDE_INT", "probe_interval", "=", "1", "<<", "PARAM_VALUE", "(", "PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL", ")", ";", "HOST_WIDE_INT", "guard_size", "=", "1", "<<", "PARAM_VALUE", "(", "PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE", ")", ";", "if", "(", "flag_stack_clash_protection", ")", "{", "if", "(", "last_probe_offset", "+", "-", "INTVAL", "(", "size", ")", "<", "guard_size", ")", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "else", "{", "rtx", "offset", "=", "GEN_INT", "(", "probe_interval", "-", "UNITS_PER_LONG", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "-", "INTVAL", "(", "size", ")", "&", "-", "probe_interval", ";", "HOST_WIDE_INT", "num_probes", "=", "rounded_size", "/", "probe_interval", ";", "HOST_WIDE_INT", "residual", "=", "-", "INTVAL", "(", "size", ")", "-", "rounded_size", ";", "if", "(", "num_probes", "<", "MIN_UNROLL_PROBES", ")", "{", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_probes", ";", "i", "++", ")", "{", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "probe_interval", ")", ",", "true", ")", ";", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "}", "dump_stack_clash_frame_info", "(", "PROBE_INLINE", ",", "residual", "!=", "0", ")", ";", "}", "else", "{", "rtx_code_label", "*", "loop_start_label", "=", "gen_label_rtx", "(", ")", ";", "s390_prologue_plus_offset", "(", "temp_reg", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "rounded_size", ")", ",", "true", ")", ";", "emit_label", "(", "loop_start_label", ")", ";", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "probe_interval", ")", ",", "false", ")", ";", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "stack_pointer_rtx", ",", "temp_reg", ",", "GT", ",", "NULL_RTX", ",", "Pmode", ",", "1", ",", "loop_start_label", ")", ";", "JUMP_LABEL", "(", "get_last_insn", "(", ")", ")", "=", "loop_start_label", ";", "LABEL_NUSES", "(", "loop_start_label", ")", "=", "1", ";", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "temp_reg", ",", "const0_rtx", ",", "true", ")", ";", "temp_reg_clobbered_p", "=", "true", ";", "dump_stack_clash_frame_info", "(", "PROBE_LOOP", ",", "residual", "!=", "0", ")", ";", "}", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "residual", ")", ",", "true", ")", ";", "last_probe_offset", "+=", "residual", ";", "if", "(", "last_probe_offset", ">=", "probe_interval", ")", "s390_emit_stack_probe", "(", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "residual", "-", "UNITS_PER_LONG", ")", ")", ")", ";", "return", "temp_reg_clobbered_p", ";", "}", "}", "s390_prologue_plus_offset", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "size", ",", "true", ")", ";", "return", "temp_reg_clobbered_p", ";", "}", "</s>" ]

[ "Allocate", "SIZE", "bytes", "of", "stack", "space", ",", "using", "TEMP_REG", "as", "a", "temporary", "if", "necessary", ".", "LAST_PROBE_OFFSET", "contains", "the", "offset", "of", "the", "closest", "probe", "relative", "to", "the", "stack", "pointer", ".", "Note", "that", "SIZE", "is", "negative", ".", "The", "return", "value", "is", "true", "if", "TEMP_REG", "has", "been", "clobbered", "." ]

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

[]

[ "<s>", "int", "Cpu0AsmParser", "::", "tryParseRegister", "(", "StringRef", "Mnemonic", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "int", "RegNum", "=", "-", "1", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "RegNum", "=", "matchRegisterName", "(", "lowerCase", ")", ";", "}", "else", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "{", "RegNum", "=", "matchRegisterByNumber", "(", "static_cast", "<", "unsigned", ">", "(", "Tok", ".", "getIntVal", "(", ")", ")", ",", "Mnemonic", ".", "lower", "(", ")", ")", ";", "}", "else", "{", "return", "RegNum", ";", "}", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "Cpu0", "Cpu0", "1" ]

[]

[ "<s>", "unsigned", "getMinPrefetchStride", "(", "unsigned", "NumMemAccesses", ",", "unsigned", "NumStridedMemAccesses", ",", "unsigned", "NumPrefetches", ",", "bool", "HasCall", ")", "const", "override", "{", "return", "MinPrefetchStride", ";", "}", "</s>" ]

[ "Some", "HW", "prefetchers", "can", "handle", "accesses", "up", "to", "a", "certain", "constant", "stride", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "inline", "bool", "inline_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "class1", ",", "reg_class_t", "class2", ",", "int", "strict", ")", "{", "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class1", ")", "||", "MAYBE_FLOAT_CLASS_P", "(", "class2", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class1", ")", "||", "MAYBE_SSE_CLASS_P", "(", "class2", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class1", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class2", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class1", ")", "||", "MAYBE_MASK_CLASS_P", "(", "class2", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "{", "gcc_assert", "(", "!", "strict", "||", "lra_in_progress", ")", ";", "return", "true", ";", "}", "if", "(", "FLOAT_CLASS_P", "(", "class1", ")", "!=", "FLOAT_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "(", "MASK_CLASS_P", "(", "class1", ")", "!=", "MASK_CLASS_P", "(", "class2", ")", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", ")", "return", "true", ";", "if", "(", "MMX_CLASS_P", "(", "class1", ")", "!=", "MMX_CLASS_P", "(", "class2", ")", ")", "return", "true", ";", "if", "(", "SSE_CLASS_P", "(", "class1", ")", "!=", "SSE_CLASS_P", "(", "class2", ")", ")", "{", "if", "(", "!", "TARGET_SSE2", ")", "return", "true", ";", "if", "(", "(", "SSE_CLASS_P", "(", "class1", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "||", "(", "SSE_CLASS_P", "(", "class2", ")", "&&", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "To", "optimize", "register_move_cost", "performance", ",", "allow", "inline", "variant", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "MBlazeAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "compute_convert_gain", "(", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Compute", "a", "gain", "for", "chain", "conversion", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "MipsBranchExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "IsPIC", "&&", "ABI", ".", "IsO32", "(", ")", "&&", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "MF", ",", "TII", ")", ";", "MFp", "=", "&", "MF", ";", "ForceLongBranchFirstPass", "=", "ForceLongBranch", ";", "bool", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "bool", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "bool", "fpuDelaySlotChanged", "=", "handleFPUDelaySlot", "(", ")", ";", "bool", "loadDelaySlotChanged", "=", "handleLoadDelaySlot", "(", ")", ";", "bool", "Changed", "=", "longBranchChanged", "||", "forbiddenSlotChanged", "||", "fpuDelaySlotChanged", "||", "loadDelaySlotChanged", ";", "while", "(", "forbiddenSlotChanged", ")", "{", "longBranchChanged", "=", "handlePossibleLongBranch", "(", ")", ";", "fpuDelaySlotChanged", "=", "handleFPUDelaySlot", "(", ")", ";", "loadDelaySlotChanged", "=", "handleLoadDelaySlot", "(", ")", ";", "if", "(", "!", "longBranchChanged", "&&", "!", "fpuDelaySlotChanged", "&&", "!", "loadDelaySlotChanged", ")", "break", ";", "forbiddenSlotChanged", "=", "handleForbiddenSlot", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ia64_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "next_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "ia64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "if", "(", "next_cum", ".", "words", "<", "MAX_ARGUMENT_SLOTS", ")", "{", "int", "n", "=", "MAX_ARGUMENT_SLOTS", "-", "next_cum", ".", "words", ";", "*", "pretend_size", "=", "n", "*", "UNITS_PER_WORD", ";", "cfun", "->", "machine", "->", "n_varargs", "=", "n", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ".", "We", "generate", "the", "actual", "spill", "instructions", "during", "prologue", "generation", "." ]

[ "ia64" ]

[]

[ "<s>", "static", "bool", "any_sibcall_could_use_r3", "(", "void", ")", "{", "edge_iterator", "ei", ";", "edge", "e", ";", "if", "(", "!", "crtl", "->", "tail_call_emit", ")", "return", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "if", "(", "e", "->", "flags", "&", "EDGE_SIBCALL", ")", "{", "rtx", "call", "=", "BB_END", "(", "e", "->", "src", ")", ";", "if", "(", "!", "CALL_P", "(", "call", ")", ")", "call", "=", "prev_nonnote_nondebug_insn", "(", "call", ")", ";", "gcc_assert", "(", "CALL_P", "(", "call", ")", "&&", "SIBLING_CALL_P", "(", "call", ")", ")", ";", "if", "(", "find_regno_fusage", "(", "call", ",", "USE", ",", "3", ")", "||", "is_indirect_tailcall_p", "(", "call", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "r3", "is", "used", "by", "any", "of", "the", "tail", "call", "insns", "in", "the", "current", "function", "." ]

[ "arm", "3" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "NumBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "PowerPC", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "PPCTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createPPCISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AGCAsmParser", "::", "checkEarlyTargetMatchPredicate", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Operands", ")", "{", "unsigned", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "AGC", "::", "EXTEND", ")", "{", "ParsedExtend", "=", "true", ";", "return", "Match_IgnoredExtend", ";", "}", "bool", "InstIsExtracode", "=", "MII", ".", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "AGCII", "::", "IsExtracode", ";", "if", "(", "!", "ParsingExtracode", ")", "return", "InstIsExtracode", "?", "Match_ExtracodeFail", ":", "Match_Success", ";", "return", "InstIsExtracode", "?", "Match_Success", ":", "Match_NonExtracodeFail", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "before", "rendering", "any", "operands", "to", "it", "." ]

[ "AGC", "AGC", "AGC::EXTEND", "AGCII::IsExtracode" ]

[]

[ "<s>", "void", "AArch64MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "TLSDESCCALL", ")", "{", "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_tlsdesc_call", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "CompilerBarrier", ")", "{", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint32_t", ">", "(", "Binary", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "AArch64", "AArch64", "AArch64::TLSDESCCALL", "AArch64::fixup_aarch64_tlsdesc_call", "0", "0", "AArch64::CompilerBarrier", "support::endian", "support::little" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vext", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "offset", ";", "unsigned", "int", "location", ";", "unsigned", "int", "next", "=", "d", "->", "perm", "[", "0", "]", "+", "1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "next", "++", ",", "i", "++", ")", "{", "if", "(", "next", "==", "2", "*", "nelt", ")", "return", "false", ";", "if", "(", "d", "->", "one_vector_p", "&&", "(", "next", "==", "nelt", ")", ")", "{", "if", "(", "(", "nelt", "==", "2", ")", "&&", "(", "d", "->", "vmode", "!=", "V2DImode", ")", ")", "return", "false", ";", "else", "next", "=", "0", ";", "}", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "next", ")", "return", "false", ";", "}", "location", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "gen", "=", "gen_neon_vextv16qi", ";", "break", ";", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vextv8qi", ";", "break", ";", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vextv4hi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_neon_vextv8hi", ";", "break", ";", "case", "E_V2SImode", ":", "gen", "=", "gen_neon_vextv2si", ";", "break", ";", "case", "E_V4SImode", ":", "gen", "=", "gen_neon_vextv4si", ";", "break", ";", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vextv4hf", ";", "break", ";", "case", "E_V8HFmode", ":", "gen", "=", "gen_neon_vextv8hf", ";", "break", ";", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vextv2sf", ";", "break", ";", "case", "E_V4SFmode", ":", "gen", "=", "gen_neon_vextv4sf", ";", "break", ";", "case", "E_V2DImode", ":", "gen", "=", "gen_neon_vextv2di", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "offset", "=", "GEN_INT", "(", "location", ")", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "offset", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VEXT", "insns", "." ]

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

[]

[ "<s>", "bool", "isZero", "(", ")", "const", "{", "return", "K", "==", "ConstZero", "||", "K", "==", "VariableKnownToBeZero", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

[ "PowerPC" ]

[]

[ "<s>", "SPUTargetLowering", "::", "ConstraintType", "SPUTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "ConstraintLetter", ")", "const", "{", "if", "(", "ConstraintLetter", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "ConstraintLetter", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'b'", ":", "case", "'r'", ":", "case", "'f'", ":", "case", "'v'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "ConstraintLetter", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MipsSubtarget", "*", "MipsTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeSet", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "hasMips16Attr", "=", "!", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"mips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "bool", "hasNoMips16Attr", "=", "!", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"nomips16\"", ")", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", ";", "Attribute", "SFAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"use-soft-float\"", ")", ";", "bool", "softFloat", "=", "!", "SFAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "SFAttr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ":", "Options", ".", "UseSoftFloat", ";", "if", "(", "hasMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+mips16\"", ":", "\",+mips16\"", ";", "else", "if", "(", "hasNoMips16Attr", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"-mips16\"", ":", "\",-mips16\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "+", "(", "softFloat", "?", "\"use-soft-float=true\"", ":", "\"use-soft-float=false\"", ")", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "MipsSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "isLittle", ",", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"target-cpu\"", "\"target-features\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "\"use-soft-float\"", "\"true\"", "Mips", "\"+mips16\"", "\",+mips16\"", "Mips", "\"-mips16\"", "\",-mips16\"", "\"use-soft-float=true\"", "\"use-soft-float=false\"", "Mips" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "auto", "getNodes", "=", "[", "this", "]", "(", ")", "->", "std", "::", "vector", "<", "SDNode", "*", ">", "{", "std", "::", "vector", "<", "SDNode", "*", ">", "T", ";", "T", ".", "reserve", "(", "CurDAG", "->", "allnodes_size", "(", ")", ")", ";", "for", "(", "SDNode", "&", "N", ":", "CurDAG", "->", "allnodes", "(", ")", ")", "T", ".", "push_back", "(", "&", "N", ")", ";", "return", "T", ";", "}", ";", "ppSimplifyOrSelect0", "(", "getNodes", "(", ")", ")", ";", "ppAddrReorderAddShl", "(", "getNodes", "(", ")", ")", ";", "ppAddrRewriteAndSrl", "(", "getNodes", "(", ")", ")", ";", "ppHoistZextI1", "(", "getNodes", "(", ")", ")", ";", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "\"Preprocessed (Hexagon) selection DAG:\"", ";", "CurDAG", "->", "dump", "(", ")", ";", "}", ")", ";", "if", "(", "EnableAddressRebalancing", ")", "{", "rebalanceAddressTrees", "(", ")", ";", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "\"Address tree balanced selection DAG:\"", ";", "CurDAG", "->", "dump", "(", ")", ";", "}", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "Hexagon", "Hexagon", "\"isel\"", "\"Preprocessed (Hexagon) selection DAG:\"", "\"isel\"", "\"Address tree balanced selection DAG:\"" ]

[]

[ "<s>", "static", "bool", "arm_class_likely_spilled_p", "(", "reg_class_t", "rclass", ")", "{", "if", "(", "(", "TARGET_THUMB1", "&&", "rclass", "==", "LO_REGS", ")", "||", "rclass", "==", "CC_REG", ")", "return", "true", ";", "return", "default_class_likely_spilled_p", "(", "rclass", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CLASS_LIKELY_SPILLED_P", ".", "We", "need", "to", "define", "this", "for", "LO_REGS", "on", "Thumb-1", ".", "Otherwise", "we", "can", "end", "up", "using", "r0-r4", "for", "function", "arguments", ",", "r7", "for", "the", "stack", "frame", "and", "do", "n't", "have", "enough", "left", "over", "to", "do", "doubleword", "arithmetic", ".", "For", "Thumb-2", "all", "the", "potentially", "problematic", "instructions", "accept", "high", "registers", "so", "this", "is", "not", "necessary", ".", "Care", "needs", "to", "be", "taken", "to", "avoid", "adding", "new", "Thumb-2", "patterns", "that", "require", "many", "low", "registers", "." ]

[ "arm" ]

[]

[ "<s>", "static", "void", "bfin_reorg_loops", "(", "void", ")", "{", "reorg_loops", "(", "true", ",", "&", "bfin_doloop_hooks", ")", ";", "}", "</s>" ]

[ "Run", "from", "machine_dependent_reorg", ",", "this", "pass", "looks", "for", "doloop_end", "insns", "and", "tries", "to", "rewrite", "the", "RTL", "of", "these", "loops", "so", "that", "proper", "Blackfin", "hardware", "loops", "are", "generated", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "s390_contiguous_bitmask_vector_p", "(", "rtx", "op", ",", "int", "*", "start", ",", "int", "*", "end", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "length", ",", "size", ";", "rtx", "elt", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "op", ",", "&", "elt", ")", "||", "!", "CONST_INT_P", "(", "elt", ")", ")", "return", "false", ";", "size", "=", "GET_MODE_UNIT_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "if", "(", "size", ">", "64", ")", "return", "false", ";", "mask", "=", "UINTVAL", "(", "elt", ")", ";", "if", "(", "s390_contiguous_bitmask_p", "(", "mask", ",", "size", ",", "start", ",", "end", "!=", "NULL", "?", "&", "length", ":", "NULL", ")", ")", "{", "if", "(", "end", "!=", "NULL", ")", "*", "end", "=", "*", "start", "+", "length", "-", "1", ";", "return", "true", ";", "}", "if", "(", "s390_contiguous_bitmask_p", "(", "~", "mask", ",", "size", ",", "start", ",", "end", "!=", "NULL", "?", "&", "length", ":", "NULL", ")", ")", "{", "if", "(", "end", "!=", "NULL", ")", "*", "end", "=", "*", "start", "-", "1", ";", "if", "(", "start", "!=", "NULL", ")", "*", "start", "=", "*", "start", "+", "length", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "the", "same", "contiguous", "bitfield", "in", "*", "all", "*", "its", "elements", ".", "START", "and", "END", "can", "be", "used", "to", "obtain", "the", "start", "and", "end", "position", "of", "the", "bitfield", ".", "START/STOP", "give", "the", "position", "of", "the", "first/last", "bit", "of", "the", "bitfield", "counting", "from", "the", "lowest", "order", "bit", "starting", "with", "zero", ".", "In", "order", "to", "use", "these", "values", "for", "S/390", "instructions", "this", "has", "to", "be", "converted", "to", "``", "bits", "big", "endian", "''", "style", "." ]

[ "s390", "64", "1", "1" ]

[]

[ "<s>", "static", "SDValue", "PerformIntrinsicCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "arm_neon_vqshifts", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftu", ":", "EVT", "VT", "=", "N", "->", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ";", "int64_t", "Cnt", ";", "if", "(", "!", "isVShiftLImm", "(", "N", "->", "getOperand", "(", "2", ")", ",", "VT", ",", "Cnt", ")", ")", "break", ";", "unsigned", "VShiftOpc", "=", "(", "IntNo", "==", "Intrinsic", "::", "arm_neon_vqshifts", ")", "?", "AArch64ISD", "::", "NEON_QSHLs", ":", "AArch64ISD", "::", "NEON_QSHLu", ";", "return", "DAG", ".", "getNode", "(", "VShiftOpc", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ",", "DAG", ".", "getConstant", "(", "Cnt", ",", "MVT", "::", "i32", ")", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "PerformIntrinsicCombine", "-", "ARM-specific", "DAG", "combining", "for", "intrinsics", "." ]

[ "AArch64", "0", "Intrinsic::arm_neon_vqshifts", "Intrinsic::arm_neon_vqshiftu", "1", "2", "Intrinsic::arm_neon_vqshifts", "AArch64ISD::NEON_QSHLs", "AArch64ISD::NEON_QSHLu", "0", "1", "MVT::i32" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMALFWriterPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "paired_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "if", "(", "!", "TARGET_PAIRED_FLOAT", ")", "return", "0", ";", "paired_emit_vector_compare", "(", "rcode", ",", "dest", ",", "op1", ",", "op2", ",", "cc_op0", ",", "cc_op1", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

[ "powerpcspe", "0", "1" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "DAG", "->", "addMutation", "(", "createX86MacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "StackAlignment", "(", "16", ")", ",", "DarwinDirective", "(", "PPC", "::", "DIR_NONE", ")", ",", "IsGigaProcessor", "(", "false", ")", ",", "Has64BitSupport", "(", "false", ")", ",", "Use64BitRegs", "(", "false", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "HasAltivec", "(", "false", ")", ",", "HasFSQRT", "(", "false", ")", ",", "HasSTFIWX", "(", "false", ")", ",", "HasLazyResolverStubs", "(", "false", ")", ",", "IsJITCodeModel", "(", "false", ")", ",", "DarwinVers", "(", "0", ")", "{", "std", "::", "string", "CPU", "=", "\"generic\"", ";", "CPU", "=", "GetCurrentPowerPCCPU", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "if", "(", "is64Bit", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "}", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";", "if", "(", "TT", ".", "length", "(", ")", ">", "7", ")", "{", "size_t", "DarwinPos", "=", "TT", ".", "find", "(", "\"-darwin\"", ")", ";", "if", "(", "DarwinPos", "!=", "std", "::", "string", "::", "npos", ")", "{", "if", "(", "isdigit", "(", "TT", "[", "DarwinPos", "+", "7", "]", ")", ")", "DarwinVers", "=", "atoi", "(", "&", "TT", "[", "DarwinPos", "+", "7", "]", ")", ";", "else", "DarwinVers", "=", "8", ";", "}", "}", "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "PowerPC", "PPC", "PPC", "16", "PPC::DIR_NONE", "PPC", "0", "\"generic\"", "7", "\"-darwin\"", "7", "7", "8" ]

[]

[ "<s>", "void", "ARCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Determine Callee Saves: \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SavedRegs", ".", "set", "(", "ARC", "::", "BLINK", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "ARC", "ARC", "\"Determine Callee Saves: \"", "\"\\n\"", "ARC::BLINK" ]

[]

[ "<s>", "Sparc", "::", "Fixups", "SparcMCExpr", "::", "getFixupKind", "(", "SparcMCExpr", "::", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled SparcMCExpr::VariantKind\"", ")", ";", "case", "VK_Sparc_LO", ":", "return", "Sparc", "::", "fixup_sparc_lo10", ";", "case", "VK_Sparc_HI", ":", "return", "Sparc", "::", "fixup_sparc_hi22", ";", "case", "VK_Sparc_H44", ":", "return", "Sparc", "::", "fixup_sparc_h44", ";", "case", "VK_Sparc_M44", ":", "return", "Sparc", "::", "fixup_sparc_m44", ";", "case", "VK_Sparc_L44", ":", "return", "Sparc", "::", "fixup_sparc_l44", ";", "case", "VK_Sparc_HH", ":", "return", "Sparc", "::", "fixup_sparc_hh", ";", "case", "VK_Sparc_HM", ":", "return", "Sparc", "::", "fixup_sparc_hm", ";", "case", "VK_Sparc_PC22", ":", "return", "Sparc", "::", "fixup_sparc_pc22", ";", "case", "VK_Sparc_PC10", ":", "return", "Sparc", "::", "fixup_sparc_pc10", ";", "case", "VK_Sparc_GOT22", ":", "return", "Sparc", "::", "fixup_sparc_got22", ";", "case", "VK_Sparc_GOT10", ":", "return", "Sparc", "::", "fixup_sparc_got10", ";", "case", "VK_Sparc_GOT13", ":", "return", "Sparc", "::", "fixup_sparc_got13", ";", "case", "VK_Sparc_13", ":", "return", "Sparc", "::", "fixup_sparc_13", ";", "case", "VK_Sparc_WPLT30", ":", "return", "Sparc", "::", "fixup_sparc_wplt30", ";", "case", "VK_Sparc_WDISP30", ":", "return", "Sparc", "::", "fixup_sparc_call30", ";", "case", "VK_Sparc_TLS_GD_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_hi22", ";", "case", "VK_Sparc_TLS_GD_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_lo10", ";", "case", "VK_Sparc_TLS_GD_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_add", ";", "case", "VK_Sparc_TLS_GD_CALL", ":", "return", "Sparc", "::", "fixup_sparc_tls_gd_call", ";", "case", "VK_Sparc_TLS_LDM_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_hi22", ";", "case", "VK_Sparc_TLS_LDM_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_lo10", ";", "case", "VK_Sparc_TLS_LDM_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_add", ";", "case", "VK_Sparc_TLS_LDM_CALL", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldm_call", ";", "case", "VK_Sparc_TLS_LDO_HIX22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_hix22", ";", "case", "VK_Sparc_TLS_LDO_LOX10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_lox10", ";", "case", "VK_Sparc_TLS_LDO_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ldo_add", ";", "case", "VK_Sparc_TLS_IE_HI22", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_hi22", ";", "case", "VK_Sparc_TLS_IE_LO10", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_lo10", ";", "case", "VK_Sparc_TLS_IE_LD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_ld", ";", "case", "VK_Sparc_TLS_IE_LDX", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_ldx", ";", "case", "VK_Sparc_TLS_IE_ADD", ":", "return", "Sparc", "::", "fixup_sparc_tls_ie_add", ";", "case", "VK_Sparc_TLS_LE_HIX22", ":", "return", "Sparc", "::", "fixup_sparc_tls_le_hix22", ";", "case", "VK_Sparc_TLS_LE_LOX10", ":", "return", "Sparc", "::", "fixup_sparc_tls_le_lox10", ";", "}", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "Sparc", "Sparc::Fixups", "Sparc", "Sparc", "\"Unhandled SparcMCExpr::VariantKind\"", "Sparc", "Sparc::fixup_sparc_lo10", "Sparc", "Sparc::fixup_sparc_hi22", "Sparc", "Sparc::fixup_sparc_h44", "Sparc", "Sparc::fixup_sparc_m44", "Sparc", "Sparc::fixup_sparc_l44", "Sparc", "Sparc::fixup_sparc_hh", "Sparc", "Sparc::fixup_sparc_hm", "Sparc", "Sparc::fixup_sparc_pc22", "Sparc", "Sparc::fixup_sparc_pc10", "Sparc", "Sparc::fixup_sparc_got22", "Sparc", "Sparc::fixup_sparc_got10", "Sparc", "Sparc::fixup_sparc_got13", "Sparc", "Sparc::fixup_sparc_13", "Sparc", "Sparc::fixup_sparc_wplt30", "SP", "Sparc::fixup_sparc_call30", "Sparc", "Sparc::fixup_sparc_tls_gd_hi22", "Sparc", "Sparc::fixup_sparc_tls_gd_lo10", "Sparc", "Sparc::fixup_sparc_tls_gd_add", "Sparc", "Sparc::fixup_sparc_tls_gd_call", "Sparc", "Sparc::fixup_sparc_tls_ldm_hi22", "Sparc", "Sparc::fixup_sparc_tls_ldm_lo10", "Sparc", "Sparc::fixup_sparc_tls_ldm_add", "Sparc", "Sparc::fixup_sparc_tls_ldm_call", "Sparc", "Sparc::fixup_sparc_tls_ldo_hix22", "Sparc", "Sparc::fixup_sparc_tls_ldo_lox10", "Sparc", "Sparc::fixup_sparc_tls_ldo_add", "Sparc", "Sparc::fixup_sparc_tls_ie_hi22", "Sparc", "Sparc::fixup_sparc_tls_ie_lo10", "Sparc", "Sparc::fixup_sparc_tls_ie_ld", "Sparc", "Sparc::fixup_sparc_tls_ie_ldx", "Sparc", "Sparc::fixup_sparc_tls_ie_add", "Sparc", "Sparc::fixup_sparc_tls_le_hix22", "Sparc", "Sparc::fixup_sparc_tls_le_lox10" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "const", "ARMSubtarget", "&", "Subtarget", "=", "DAG", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isAAPCS_ABI", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "Subtarget", ".", "isTargetWindows", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "0", ",", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

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

[]

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

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

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

[]

[ "<s>", "void", "m32c_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "target_memregs", ">=", "0", "&&", "target_memregs", "<=", "16", ")", "{", "for", "(", "i", "=", "(", "target_memregs", "+", "1", ")", "/", "2", ";", "i", "<", "8", ";", "i", "++", ")", "{", "fixed_regs", "[", "MEM0_REGNO", "+", "i", "]", "=", "1", ";", "CLEAR_HARD_REG_BIT", "(", "reg_class_contents", "[", "MEM_REGS", "]", ",", "MEM0_REGNO", "+", "i", ")", ";", "}", "}", "if", "(", "TARGET_A24", ")", "{", "call_used_regs", "[", "R1_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "R2_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "R3_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "A0_REGNO", "]", "=", "0", ";", "call_used_regs", "[", "A1_REGNO", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "Implements", "CONDITIONAL_REGISTER_USAGE", ".", "We", "adjust", "the", "number", "of", "available", "memregs", ",", "and", "select", "which", "registers", "need", "to", "be", "preserved", "across", "calls", "based", "on", "the", "chip", "family", "." ]

[ "m32c", "0", "16", "1", "2", "8", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "generate_set_vrsave", "(", "rtx", "reg", ",", "rs6000_stack_t", "*", "info", ",", "int", "epiloguep", ")", "{", "int", "nclobs", ",", "i", ";", "rtx", "insn", ",", "clobs", "[", "TOTAL_ALTIVEC_REGS", "+", "1", "]", ";", "rtx", "vrsave", "=", "gen_rtx_REG", "(", "SImode", ",", "VRSAVE_REGNO", ")", ";", "clobs", "[", "0", "]", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "vrsave", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "SImode", ",", "gen_rtvec", "(", "2", ",", "reg", ",", "vrsave", ")", ",", "UNSPECV_SET_VRSAVE", ")", ")", ";", "nclobs", "=", "1", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "info", "->", "vrsave_mask", "&", "ALTIVEC_REG_BIT", "(", "i", ")", ")", "{", "if", "(", "!", "epiloguep", "||", "call_used_regs", "[", "i", "]", ")", "clobs", "[", "nclobs", "++", "]", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "V4SImode", ",", "i", ")", ")", ";", "else", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SImode", ",", "i", ")", ";", "clobs", "[", "nclobs", "++", "]", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "gen_rtx_UNSPEC", "(", "V4SImode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "27", ")", ")", ";", "}", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nclobs", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nclobs", ";", "++", "i", ")", "XVECEXP", "(", "insn", ",", "0", ",", "i", ")", "=", "clobs", "[", "i", "]", ";", "return", "insn", ";", "}", "</s>" ]

[ "Returns", "an", "insn", "that", "has", "a", "vrsave", "set", "operation", "with", "the", "appropriate", "CLOBBERs", "." ]

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

[]

[ "<s>", "enum", "reg_class", "m68k_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "regno", ";", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "ADDR_REGS", ")", "&&", "!", "(", "INT_REGNO_P", "(", "regno", ")", "||", "CONSTANT_P", "(", "x", ")", ")", ")", "return", "DATA_REGS", ";", "if", "(", "TARGET_PCREL", "&&", "!", "reg_class_subset_p", "(", "rclass", ",", "ADDR_REGS", ")", "&&", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "ADDR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "SECONDARY_RELOAD_CLASS", "." ]

[ "m68k", "1" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "sparc_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE_SIZE", "(", "from", ")", "==", "4", "&&", "GET_MODE_SIZE", "(", "to", ")", "!=", "4", ")", "return", "!", "reg_classes_intersect_p", "(", "rclass", ",", "FP_REGS", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "Borrowed", "from", "the", "PA", "port", ".", "SImode", "loads", "to", "floating-point", "registers", "are", "not", "zero-extended", ".", "The", "definition", "for", "LOAD_EXTEND_OP", "specifies", "that", "integer", "loads", "narrower", "than", "BITS_PER_WORD", "will", "be", "zero-extended", ".", "As", "a", "result", ",", "we", "inhibit", "changes", "from", "SImode", "unless", "they", "are", "to", "a", "mode", "that", "is", "identical", "in", "size", ".", "Likewise", "for", "SFmode", ",", "since", "word-mode", "paradoxical", "subregs", "are", "problematic", "on", "big-endian", "architectures", "." ]

[ "sparc", "4", "4" ]

[]

[ "<s>", "const", "uint32_t", "*", "getNoPreservedMask", "(", ")", "const", "override", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "tree", "ix86_veclibabi_acml", "(", "combined_fn", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "20", "]", "=", "\"__vr.._\"", ";", "tree", "fntype", ",", "new_fndecl", ",", "args", ";", "unsigned", "arity", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "TARGET_64BIT", "||", "!", "flag_unsafe_math_optimizations", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_SIN", ":", "CASE_CFN_COS", ":", "CASE_CFN_EXP", ":", "CASE_CFN_LOG", ":", "CASE_CFN_LOG2", ":", "CASE_CFN_LOG10", ":", "if", "(", "el_mode", "==", "DFmode", "&&", "n", "==", "2", ")", "{", "name", "[", "4", "]", "=", "'d'", ";", "name", "[", "5", "]", "=", "'2'", ";", "}", "else", "if", "(", "el_mode", "==", "SFmode", "&&", "n", "==", "4", ")", "{", "name", "[", "4", "]", "=", "'s'", ";", "name", "[", "5", "]", "=", "'4'", ";", "}", "else", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "tree", "fndecl", "=", "mathfn_built_in", "(", "el_mode", "==", "DFmode", "?", "double_type_node", ":", "float_type_node", ",", "fn", ")", ";", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "sprintf", "(", "name", "+", "7", ",", "\"%s\"", ",", "bname", "+", "10", ")", ";", "arity", "=", "0", ";", "for", "(", "args", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "arity", "++", ";", "if", "(", "arity", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", ")", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineInstr", "*", "MI", "=", "&", "MBB", ".", "front", "(", ")", ";", "MachineRegisterInfo", "&", "MR", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "NVPTXRegisterInfo", "*", "NRI", "=", "MF", ".", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "bool", "Is64Bit", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "is64Bit", "(", ")", ";", "unsigned", "CvtaLocalOpcode", "=", "(", "Is64Bit", "?", "NVPTX", "::", "cvta_local_yes_64", ":", "NVPTX", "::", "cvta_local_yes", ")", ";", "unsigned", "MovDepotOpcode", "=", "(", "Is64Bit", "?", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ":", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ";", "if", "(", "!", "MR", ".", "use_empty", "(", "NRI", "->", "getFrameRegister", "(", "MF", ")", ")", ")", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "CvtaLocalOpcode", ")", ",", "NRI", "->", "getFrameRegister", "(", "MF", ")", ")", ".", "addReg", "(", "NRI", "->", "getFrameLocalRegister", "(", "MF", ")", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "MovDepotOpcode", ")", ",", "NRI", "->", "getFrameLocalRegister", "(", "MF", ")", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Shrink-wrapping not yet supported\"", "NVPTX", "NVPTX", "NVPTX", "NVPTX::cvta_local_yes_64", "NVPTX::cvta_local_yes", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::MOV_DEPOT_ADDR" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "X86" ]

[]