Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "LowerFormalArguments_SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

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

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

[ "PowerPC" ]

[]

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

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "pass_shorten_memrefs", "::", "regno_map", "*", "pass_shorten_memrefs", "::", "analyze", "(", "basic_block", "bb", ")", "{", "regno_map", "*", "m", "=", "hash_map", "<", "regno_hash", ",", "int", ">", "::", "create_ggc", "(", "10", ")", ";", "rtx_insn", "*", "insn", ";", "regstat_init_n_sets_and_refs", "(", ")", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "continue", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "rtx", "mem", "=", "XEXP", "(", "pat", ",", "i", ")", ";", "rtx", "addr", ";", "bool", "extend", "=", "false", ";", "if", "(", "get_si_mem_base_reg", "(", "mem", ",", "&", "addr", ",", "&", "extend", ")", ")", "{", "HOST_WIDE_INT", "regno", "=", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "if", "(", "i", "==", "0", ")", "{", "if", "(", "XEXP", "(", "pat", ",", "1", ")", "==", "CONST0_RTX", "(", "GET_MODE", "(", "XEXP", "(", "pat", ",", "1", ")", ")", ")", ")", "continue", ";", "}", "if", "(", "REG_N_REFS", "(", "regno", ")", "<", "4", ")", "continue", ";", "m", "->", "get_or_insert", "(", "regno", ")", "++", ";", "}", "}", "}", "regstat_free_n_sets_and_refs", "(", ")", ";", "return", "m", ";", "}", "</s>" ]

[ "Count", "how", "many", "times", "each", "regno", "is", "referenced", "as", "base", "address", "for", "a", "memory", "access", "." ]

[ "riscv", "10", "0", "2", "0", "0", "1", "1", "4" ]

[]

[ "<s>", "int", "nios2_label_align", "(", "rtx", "label", ")", "{", "int", "n", "=", "CODE_LABEL_NUMBER", "(", "label", ")", ";", "if", "(", "label_align", "&&", "n", ">=", "min_labelno", "&&", "n", "<=", "max_labelno", ")", "return", "MAX", "(", "label_align", "[", "n", "-", "min_labelno", "]", ",", "align_labels_log", ")", ";", "return", "align_labels_log", ";", "}", "</s>" ]

[ "Implement", "LABEL_ALIGN", ",", "using", "the", "information", "gathered", "in", "nios2_reorg", "." ]

[ "nios2" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "ARM", "::", "CCRRegClass", ")", "return", "0", ";", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "ARM", "ARM", "ARM::CCRRegClass", "0" ]

[]

[ "<s>", "bool", "RISCVDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "SDValue", "Base", ",", "Offset", ";", "selectMemRegAddr", "(", "Op", ",", "Base", ",", "Offset", ")", ";", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Offset", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "void", "MipsMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "case", "Mips", "::", "DROTR", ":", "case", "Mips", "::", "DSLL_MM64R6", ":", "case", "Mips", "::", "DSRA_MM64R6", ":", "case", "Mips", "::", "DROTR_MM64R6", ":", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DINS", ":", "LowerDins", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BOVC", ":", "case", "Mips", "::", "BOVC_MMR6", ":", "case", "Mips", "::", "BNVC", ":", "case", "Mips", "::", "BNVC_MMR6", ":", "LowerCompactBranch", "(", "TmpInst", ")", ";", "}", "unsigned", "long", "N", "=", "Fixups", ".", "size", "(", ")", ";", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "Opcode", "=", "TmpInst", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "Mips", "::", "NOP", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL", ")", "&&", "(", "Opcode", "!=", "Mips", "::", "SLL_MM", ")", "&&", "!", "Binary", ")", "llvm_unreachable", "(", "\"unimplemented opcode in encodeInstruction()\"", ")", ";", "int", "NewOpcode", "=", "-", "1", ";", "if", "(", "isMicroMips", "(", "STI", ")", ")", "{", "if", "(", "isMips32r6", "(", "STI", ")", ")", "{", "NewOpcode", "=", "Mips", "::", "MipsR62MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Std2MicroMipsR6", "(", "Opcode", ",", "Mips", "::", "Arch_micromipsr6", ")", ";", "}", "else", "NewOpcode", "=", "Mips", "::", "Std2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_micromips", ")", ";", "if", "(", "NewOpcode", "==", "-", "1", ")", "NewOpcode", "=", "Mips", "::", "Dsp2MicroMips", "(", "Opcode", ",", "Mips", "::", "Arch_mmdsp", ")", ";", "if", "(", "NewOpcode", "!=", "-", "1", ")", "{", "if", "(", "Fixups", ".", "size", "(", ")", ">", "N", ")", "Fixups", ".", "pop_back", "(", ")", ";", "Opcode", "=", "NewOpcode", ";", "TmpInst", ".", "setOpcode", "(", "NewOpcode", ")", ";", "Binary", "=", "getBinaryCodeForInstr", "(", "TmpInst", ",", "Fixups", ",", "STI", ")", ";", "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "TmpInst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "llvm_unreachable", "(", "\"Desc.getSize() returns 0\"", ")", ";", "EmitInstruction", "(", "Binary", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::DSLL", "Mips::DSRL", "Mips::DSRA", "Mips::DROTR", "Mips::DSLL_MM64R6", "Mips::DSRA_MM64R6", "Mips::DROTR_MM64R6", "Mips::DINS", "Mips::BEQC", "Mips::BNEC", "Mips::BOVC", "Mips::BOVC_MMR6", "Mips::BNVC", "Mips::BNVC_MMR6", "Mips::NOP", "Mips::SLL", "Mips::SLL_MM", "\"unimplemented opcode in encodeInstruction()\"", "1", "Mips", "Mips", "Mips::MipsR62MicroMipsR6", "Mips::Arch_micromipsr6", "1", "Mips::Std2MicroMipsR6", "Mips::Arch_micromipsr6", "Mips::Std2MicroMips", "Mips::Arch_micromips", "1", "Mips::Dsp2MicroMips", "Mips::Arch_mmdsp", "1", "\"Desc.getSize() returns 0\"" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_simple_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_DIRECT_MOVE", "&&", "(", "(", "mode", "==", "SDmode", ")", "||", "(", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", ")", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "||", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "else", "if", "(", "TARGET_MFPGPR", "&&", "TARGET_POWERPC64", "&&", "size", "==", "8", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "FPR_REG_TYPE", ")", "||", "(", "to_type", "==", "FPR_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "else", "if", "(", "(", "size", "==", "4", "||", "(", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", ")", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "SPR_REG_TYPE", ")", "||", "(", "to_type", "==", "SPR_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_secondary_reload", "to", "return", "true", "if", "a", "move", "to", "a", "different", "register", "classe", "is", "really", "a", "simple", "move", "." ]

[ "rs6000", "8", "8", "4", "8" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "return", "CSR_NaCl_SaveList", ";", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "return", "RegList", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"" ]

[]

[ "<s>", "bool", "addPassesToEmitMC", "(", "PassManagerBase", "&", ",", "MCContext", "*", "&", ",", "raw_ostream", "&", ",", "bool", "=", "true", ")", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "machine", "code", "emitted", "with", "the", "MCJIT", "." ]

[ "NVPTX" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_move", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "!", "BYTES_BIG_ENDIAN", "&&", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "TARGET_P9_VECTOR", "&&", "!", "gpr_or_gpr_p", "(", "dest", ",", "source", ")", "&&", "(", "MEM_P", "(", "source", ")", "^", "MEM_P", "(", "dest", ")", ")", ")", ";", "if", "(", "MEM_P", "(", "source", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "dest", ")", "||", "GET_CODE", "(", "dest", ")", "==", "SUBREG", ")", ";", "rs6000_emit_le_vsx_load", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "else", "{", "if", "(", "!", "REG_P", "(", "source", ")", ")", "source", "=", "force_reg", "(", "mode", ",", "source", ")", ";", "rs6000_emit_le_vsx_store", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "sequence", "representing", "a", "little-endian", "VSX", "load", "or", "store", ",", "moving", "data", "from", "SOURCE", "to", "DEST", "in", "mode", "MODE", ".", "This", "is", "done", "separately", "from", "rs6000_emit_move", "to", "ensure", "it", "is", "called", "only", "during", "expand", ".", "LE", "VSX", "loads", "and", "stores", "introduced", "later", "are", "handled", "with", "a", "split", ".", "The", "expand-time", "RTL", "generation", "allows", "us", "to", "optimize", "away", "redundant", "pairs", "of", "register-permutes", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "ARM64MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "{", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"did not expect relocated expression\"", ")", ";", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "assert", "(", "0", "&&", "\"Unable to encode MCOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"did not expect relocated expression\"", "0", "\"Unable to encode MCOperand!\"", "0" ]

[]

[ "<s>", "bool", "MipsCCState", "::", "originalTypeIsF128", "(", "const", "Type", "*", "Ty", ",", "const", "char", "*", "Func", ")", "{", "if", "(", "Ty", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "if", "(", "Ty", "->", "isStructTy", "(", ")", "&&", "Ty", "->", "getStructNumElements", "(", ")", "==", "1", "&&", "Ty", "->", "getStructElementType", "(", "0", ")", "->", "isFP128Ty", "(", ")", ")", "return", "true", ";", "return", "(", "Func", "&&", "Ty", "->", "isIntegerTy", "(", "128", ")", "&&", "isF128SoftLibCall", "(", "Func", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "Ty", "is", "fp128", ",", "{", "f128", "}", "or", "i128", "which", "was", "originally", "a", "fp128", "." ]

[ "Mips", "Mips", "1", "0", "128" ]

[]

[ "<s>", "static", "void", "set_pic_reg_ever_live", "(", ")", "{", "if", "(", "reload_in_progress", ")", "df_set_regs_ever_live", "(", "REGNO", "(", "pic_offset_table_rtx", ")", ",", "true", ")", ";", "}", "</s>" ]

[ "Set", "regs_ever_live", "for", "PIC", "base", "address", "register", "to", "true", "if", "required", "." ]

[ "i386" ]

[]

[ "<s>", "OperandMatchResultTy", "SystemZAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "bool", "Result", "=", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ",", "true", ")", ";", "bool", "PendingErrors", "=", "getParser", "(", ")", ".", "hasPendingError", "(", ")", ";", "getParser", "(", ")", ".", "clearPendingErrors", "(", ")", ";", "if", "(", "PendingErrors", ")", "return", "MatchOperand_ParseFail", ";", "if", "(", "Result", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "TargetMachine", "&", "TM", ",", "bool", "IsLittle", ",", "const", "TargetOptions", "&", "Options", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "ARMProcClass", "(", "None", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "Options", ")", ",", "TargetABI", "(", "ARM_ABI_UNKNOWN", ")", ",", "DL", "(", "computeDataLayout", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ")", ",", "TSInfo", "(", "DL", ")", ",", "JITInfo", "(", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "FrameLowering", "(", "!", "isThumb1Only", "(", ")", "?", "new", "ARMFrameLowering", "(", "*", "this", ")", ":", "(", "ARMFrameLowering", "*", ")", "new", "Thumb1FrameLowering", "(", "*", "this", ")", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "bool", "Ried", "=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "if", "(", "Ried", ")", "{", "Changed", "=", "true", ";", "BT", ".", "run", "(", ")", ";", "}", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "*", "MDT", ",", "HII", ",", "HRI", ",", "MRI", ",", "MF", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "delete", "[", "]", "gv_array", ";", "if", "(", "HasDebugInfo", ")", "OutStreamer", "->", "EmitRawText", "(", "\"//\\t}\"", ")", ";", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "outputDwarfFileDirectives", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "0", "\"//\\t}\"", "NVPTX" ]

[]

[ "<s>", "bool", "VESubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "AMDGPUASI", "=", "TM", ".", "getAMDGPUAS", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "(", "ScalarVT", "!=", "MVT", "::", "f32", "&&", "ScalarVT", "!=", "MVT", "::", "f64", ")", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

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

[]

[ "<s>", "int", "HexagonFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "auto", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "NoOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "unsigned", "SP", "=", "HRI", ".", "getStackRegister", "(", ")", ",", "FP", "=", "HRI", ".", "getFrameRegister", "(", ")", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "AP", "=", "HMFI", ".", "getStackAlignBasePhysReg", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "UseFP", "=", "false", ",", "UseAP", "=", "false", ";", "if", "(", "NoOpt", "&&", "!", "HasExtraAlign", ")", "UseFP", "=", "true", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "||", "MFI", ".", "isObjectPreAllocated", "(", "FI", ")", ")", "{", "UseFP", "|=", "(", "HasAlloca", "||", "HasExtraAlign", ")", ";", "}", "else", "{", "if", "(", "HasAlloca", ")", "{", "if", "(", "HasExtraAlign", ")", "UseAP", "=", "true", ";", "else", "UseFP", "=", "true", ";", "}", "}", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "assert", "(", "(", "HasFP", "||", "!", "UseFP", ")", "&&", "\"This function must have frame pointer\"", ")", ";", "if", "(", "Offset", ">", "0", "&&", "!", "HasFP", ")", "Offset", "-=", "8", ";", "if", "(", "UseFP", ")", "FrameReg", "=", "FP", ";", "else", "if", "(", "UseAP", ")", "FrameReg", "=", "AP", ";", "else", "FrameReg", "=", "SP", ";", "int", "RealOffset", "=", "Offset", ";", "if", "(", "!", "UseFP", "&&", "!", "UseAP", "&&", "HasFP", ")", "RealOffset", "=", "FrameSize", "+", "Offset", ";", "return", "RealOffset", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"This function must have frame pointer\"", "0", "8" ]

[]

[ "<s>", "void", "TriCoreMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "getSize", "(", ")", "!=", "4", ")", "{", "llvm_unreachable", "(", "\"Unexpected instruction size!\"", ")", ";", "}", "const", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitConstant", "(", "Binary", ",", "Desc", ".", "getSize", "(", ")", ",", "OS", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "4", "\"Unexpected instruction size!\"" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int64_t", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FramePtr", "=", "SP", "::", "I6", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "FramePtr", "=", "SP", "::", "O6", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "Offset", "+=", "(", "stackSize", ")", "?", "Subtarget", ".", "getAdjustedFrameSize", "(", "stackSize", ")", ":", "0", ";", "}", "if", "(", "Offset", ">=", "-", "4096", "&&", "Offset", "<=", "4095", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FramePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "OffHi", "=", "(", "unsigned", ")", "Offset", ">>", "10U", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDrr", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addReg", "(", "FramePtr", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "SP", "::", "G1", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "1", "Sparc", "Sparc", "SP::I6", "SP::O6", "0", "4096", "4095", "1", "10U", "SP::SETHIi", "SP::G1", "SP::ADDrr", "SP::G1", "SP::G1", "SP::G1", "1", "1", "10", "1" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "const", "ARMBaseTargetMachine", "&", "ARM_TM", "=", "static_cast", "<", "const", "ARMBaseTargetMachine", "&", ">", "(", "TM", ")", ";", "bool", "isAAPCS_ABI", "=", "ARM_TM", ".", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARMABI", "::", "ARM_ABI_AAPCS", ";", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "isAAPCS_ABI", ")", ";", "if", "(", "isAAPCS_ABI", ")", "{", "LSDASection", "=", "nullptr", ";", "}", "AttributesSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".ARM.attributes\"", ",", "ELF", "::", "SHT_ARM_ATTRIBUTES", ",", "0", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARMABI::ARM_ABI_AAPCS", "\".ARM.attributes\"", "ARM", "0" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", ")", "." ]

[ "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "0", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "return", "isStridedLoad", "(", "Mask", ")", "!=", "StridedLoadKind", "::", "NoPattern", ";", "return", "true", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "usesGlobalOffsetTable", "(", ")", ")", "return", "DAG", ".", "getGLOBAL_OFFSET_TABLE", "(", "getPointerTy", "(", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "GlobalBaseReg", ",", "DebugLoc", "::", "getUnknownLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "X86", "X86", "X86ISD::GlobalBaseReg" ]

[]

[ "<s>", "static", "bool", "aarch64_handle_attr_isa_flags", "(", "char", "*", "str", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", ";", "unsigned", "long", "isa_flags", "=", "aarch64_isa_flags", ";", "if", "(", "strncmp", "(", "\"+nothing\"", ",", "str", ",", "8", ")", "==", "0", ")", "{", "isa_flags", "=", "0", ";", "str", "+=", "8", ";", "}", "parse_res", "=", "aarch64_parse_extension", "(", "str", ",", "&", "isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "aarch64_isa_flags", "=", "isa_flags", ";", "return", "true", ";", "}", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing value in %<target()%> pragma or attribute\"", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid value (\\\"%s\\\") in %<target()%> pragma or attribute\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Parse", "an", "architecture", "extensions", "target", "attribute", "string", "specified", "in", "STR", ".", "For", "example", "``", "+fp+nosimd", "''", ".", "Show", "any", "errors", "if", "needed", ".", "Return", "TRUE", "if", "successful", ".", "Update", "aarch64_isa_flags", "to", "reflect", "the", "ISA", "features", "modified", ".", "PRAGMA_OR_ATTR", "is", "used", "in", "potential", "error", "messages", "." ]

[ "aarch64", "\"+nothing\"", "8", "0", "0", "8", "\"missing value in %<target()%> pragma or attribute\"", "\"invalid value (\\\"%s\\\") in %<target()%> pragma or attribute\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isPreSt", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "STRWpre", ":", "case", "AArch64", "::", "STRXpre", ":", "case", "AArch64", "::", "STRSpre", ":", "case", "AArch64", "::", "STRDpre", ":", "case", "AArch64", "::", "STRQpre", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "pre-indexed", "store", "." ]

[ "AArch64", "AArch64", "AArch64::STRWpre", "AArch64::STRXpre", "AArch64::STRSpre", "AArch64::STRDpre", "AArch64::STRQpre" ]

[]

[ "<s>", "void", "LEGPassConfig", "::", "addPreEmitPass", "(", ")", "{", "}", "</s>" ]

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

[ "LEG", "LEG" ]

[]

[ "<s>", "void", "ix86_expand_copysign", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "op0", ",", "op1", ",", "mask", ",", "nmask", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "op1", "=", "operands", "[", "2", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "else", "vmode", "=", "mode", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "CONST_DOUBLE", ")", "{", "rtx", "(", "*", "copysign_insn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op0", ")", ")", ")", "op0", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op0", ",", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "op0", "==", "CONST0_RTX", "(", "mode", ")", ")", "op0", "=", "CONST0_RTX", "(", "vmode", ")", ";", "else", "{", "rtx", "v", "=", "ix86_build_const_vector", "(", "vmode", ",", "false", ",", "op0", ")", ";", "op0", "=", "force_reg", "(", "vmode", ",", "v", ")", ";", "}", "}", "else", "if", "(", "op0", "!=", "CONST0_RTX", "(", "mode", ")", ")", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "0", ",", "0", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "copysign_insn", "=", "gen_copysignsf3_const", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "copysign_insn", "=", "gen_copysigndf3_const", ";", "else", "copysign_insn", "=", "gen_copysigntf3_const", ";", "emit_insn", "(", "copysign_insn", "(", "dest", ",", "op0", ",", "op1", ",", "mask", ")", ")", ";", "}", "else", "{", "rtx", "(", "*", "copysign_insn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "nmask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "0", ",", "1", ")", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "0", ",", "0", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "copysign_insn", "=", "gen_copysignsf3_var", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "copysign_insn", "=", "gen_copysigndf3_var", ";", "else", "copysign_insn", "=", "gen_copysigntf3_var", ";", "emit_insn", "(", "copysign_insn", "(", "dest", ",", "NULL_RTX", ",", "op0", ",", "op1", ",", "nmask", ",", "mask", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "BPFRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "BPF", "::", "R10", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::R10" ]

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Mips", "::", "FP", ":", "Mips", "::", "SP", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::FP", "Mips::SP" ]

[]

[ "<s>", "static", "bool", "s390_loadrelative_operand_p", "(", "rtx", "addr", ",", "rtx", "*", "symref", ",", "HOST_WIDE_INT", "*", "addend", ")", "{", "HOST_WIDE_INT", "tmpaddend", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "tmpaddend", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "||", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_GOTENT", "||", "XINT", "(", "addr", ",", "1", ")", "==", "UNSPEC_PLT31", ")", ")", ")", "{", "if", "(", "symref", ")", "*", "symref", "=", "addr", ";", "if", "(", "addend", ")", "*", "addend", "=", "tmpaddend", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "ADDR", "is", "an", "operand", "valid", "for", "a", "load/store", "relative", "instruction", ".", "Be", "aware", "that", "the", "alignment", "of", "the", "operand", "needs", "to", "be", "checked", "separately", ".", "Valid", "addresses", "are", "single", "references", "or", "a", "sum", "of", "a", "reference", "and", "a", "constant", "integer", ".", "Return", "these", "parts", "in", "SYMREF", "and", "ADDEND", ".", "You", "can", "pass", "NULL", "in", "REF", "and/or", "ADDEND", "if", "you", "are", "not", "interested", "in", "these", "values", ".", "Literal", "pool", "references", "are", "*", "not", "*", "considered", "symbol", "references", "." ]

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

[]

[ "<s>", "const", "char", "*", "thumb_call_via_reg", "(", "rtx", "reg", ")", "{", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "rtx", "*", "labelp", ";", "gcc_assert", "(", "regno", "<", "LR_REGNUM", ")", ";", "if", "(", "in_text_section", "(", ")", ")", "{", "thumb_call_reg_needed", "=", "1", ";", "if", "(", "thumb_call_via_label", "[", "regno", "]", "==", "NULL", ")", "thumb_call_via_label", "[", "regno", "]", "=", "gen_label_rtx", "(", ")", ";", "labelp", "=", "thumb_call_via_label", "+", "regno", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "call_via", "[", "regno", "]", "==", "NULL", ")", "cfun", "->", "machine", "->", "call_via", "[", "regno", "]", "=", "gen_label_rtx", "(", ")", ";", "labelp", "=", "cfun", "->", "machine", "->", "call_via", "+", "regno", ";", "}", "output_asm_insn", "(", "\"bl\\t%a0\"", ",", "labelp", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "call-via", "instruction", "for", "thumb", "state", "." ]

[ "arm", "1", "\"bl\\t%a0\"", "\"\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M68k MOVEM collapser pass\"", ";", "}", "</s>" ]

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

[ "M68k", "\"M68k MOVEM collapser pass\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "IntRegsRegClass", "}", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", "}", ";", "}", "break", ";", "case", "'a'", ":", "if", "(", "VT", "!=", "MVT", "::", "i32", ")", "return", "{", "0u", ",", "nullptr", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "ModRegsRegClass", "}", ";", "case", "'q'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "64", ":", "case", "128", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxQRRegClass", "}", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "case", "512", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "case", "1024", ":", "if", "(", "Subtarget", ".", "hasV60Ops", "(", ")", "&&", "Subtarget", ".", "useHVX128BOps", "(", ")", ")", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxVRRegClass", "}", ";", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "case", "2048", ":", "return", "{", "0u", ",", "&", "Hexagon", "::", "HvxWRRegClass", "}", ";", "}", "break", ";", "default", ":", "return", "{", "0u", ",", "nullptr", "}", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "0", "0u", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "0u", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0u", "Hexagon::DoubleRegsRegClass", "MVT::i32", "0u", "0u", "Hexagon::ModRegsRegClass", "0u", "64", "128", "0u", "Hexagon::HvxQRRegClass", "0u", "512", "0u", "Hexagon::HvxVRRegClass", "1024", "0u", "Hexagon::HvxVRRegClass", "0u", "Hexagon::HvxWRRegClass", "2048", "0u", "Hexagon::HvxWRRegClass", "0u" ]

[]

[ "<s>", "bool", "M68kExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "M68kSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "isTypeLegal", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "MVT::i1", "64" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "JIT", ",", "RM", ")", ",", "getEffectiveX86CodeModel", "(", "CM", ",", "JIT", ",", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "IsJIT", "(", "JIT", ")", "{", "if", "(", "TT", ".", "isPS4", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "TT", ".", "isOSBinFormatMachO", "(", ")", ";", "}", "setMachineOutliner", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "int", "aarch64_hard_regno_nregs", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "switch", "(", "aarch64_regno_regclass", "(", "regno", ")", ")", "{", "case", "FP_REGS", ":", "case", "FP_LO_REGS", ":", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_VREG", "-", "1", ")", "/", "UNITS_PER_VREG", ";", "default", ":", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

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

[]

[ "<s>", "static", "rtx", "sparc_tls_got", "(", "void", ")", "{", "if", "(", "flag_pic", ")", "{", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "pic_offset_table_rtx", ";", "}", "if", "(", "TARGET_SUN_TLS", "&&", "TARGET_ARCH32", ")", "{", "load_got_register", "(", ")", ";", "return", "global_offset_table_rtx", ";", "}", "return", "copy_to_reg", "(", "sparc_got", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "Global", "Offset", "Table", "to", "be", "used", "in", "TLS", "mode", "." ]

[ "sparc", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "else", "if", "(", "isSVEFunction", "(", "*", "MF", ")", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "else", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "addLiveInAttr", "(", "Register", "VReg", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "{", "LiveInAttrs", ".", "push_back", "(", "std", "::", "make_pair", "(", "VReg", ",", "Flags", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "associates", "attributes", "for", "each", "live-in", "virtual", "register", "." ]

[ "PowerPC", "ISD::ArgFlagsTy" ]

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "clear", "(", "const", "RegisterAggr", "&", "RG", ")", "{", "Units", ".", "reset", "(", "RG", ".", "Units", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "s390_match_ccmode", "(", "rtx_insn", "*", "insn", ",", "machine_mode", "req_mode", ")", "{", "int", "i", ";", "if", "(", "req_mode", "==", "VOIDmode", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "return", "s390_match_ccmode_set", "(", "PATTERN", "(", "insn", ")", ",", "req_mode", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", "if", "(", "!", "s390_match_ccmode_set", "(", "set", ",", "req_mode", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "every", "SET", "in", "INSN", "that", "sets", "the", "CC", "register", "has", "source", "and", "destination", "with", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "arc_predicate_delay_insns", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "arc" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FABS", ":", "return", "LowerF64Op", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::FNEG", "ISD::FABS", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "static", "bool", "is_load_insn1", "(", "rtx", "pat", ")", "{", "if", "(", "!", "pat", "||", "pat", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "return", "is_mem_ref", "(", "SET_SRC", "(", "pat", ")", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "is_load_insn1", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "PAT", "is", "a", "PATTERN", "of", "a", "load", "insn", "." ]

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

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "FI", ",", "RegScavenger", "*", "RS", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_SPILL_S1024_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ":", "return", "spillSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "case", "AMDGPU", "::", "SI_SPILL_S1024_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ":", "return", "restoreSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "default", ":", "llvm_unreachable", "(", "\"not an SGPR spill instruction\"", ")", ";", "}", "}", "</s>" ]

[ "Special", "case", "of", "eliminateFrameIndex", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_SPILL_S1024_SAVE", "AMDGPU::SI_SPILL_S512_SAVE", "AMDGPU::SI_SPILL_S256_SAVE", "AMDGPU::SI_SPILL_S160_SAVE", "AMDGPU::SI_SPILL_S128_SAVE", "AMDGPU::SI_SPILL_S96_SAVE", "AMDGPU::SI_SPILL_S64_SAVE", "AMDGPU::SI_SPILL_S32_SAVE", "AMDGPU::SI_SPILL_S1024_RESTORE", "AMDGPU::SI_SPILL_S512_RESTORE", "AMDGPU::SI_SPILL_S256_RESTORE", "AMDGPU::SI_SPILL_S160_RESTORE", "AMDGPU::SI_SPILL_S128_RESTORE", "AMDGPU::SI_SPILL_S96_RESTORE", "AMDGPU::SI_SPILL_S64_RESTORE", "AMDGPU::SI_SPILL_S32_RESTORE", "\"not an SGPR spill instruction\"" ]

[]

[ "<s>", "bool", "aarch64_regno_ok_for_index_p", "(", "int", "regno", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", "{", "if", "(", "!", "strict_p", ")", "return", "true", ";", "if", "(", "!", "reg_renumber", ")", "return", "false", ";", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "}", "return", "GP_REGNUM_P", "(", "regno", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "is", "a", "valid", "index", "register", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "use_32bit_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "int", "i", ";", "if", "(", "msp430_hwmult_type", "==", "MSP430_HWMULT_LARGE", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "MSP430_HWMULT_AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "cached_result", "=", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", "==", "4", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "has", "a", "second", "generation", "32-bit", "hardware", "multiplier", "." ]

[ "msp430", "0", "4" ]

[]

[ "<s>", "EVT", "getVectorVT", "(", "EVT", "ElemVT", ",", "unsigned", "NumElems", ")", "const", "{", "return", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "ElemVT", ",", "NumElems", ")", ";", "}", "</s>" ]

[ "Returns", "the", "EVT", "that", "represents", "a", "vector", "EC.Min", "elements", "in", "length", ",", "where", "each", "element", "is", "of", "type", "VT", "." ]

[ "VE" ]

[]

[ "<s>", "static", "void", "arc_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cpu %s\\n\"", ",", "arc_cpu_string", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", ",", "ATTRIBUTE_PCS", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", ",", "TARGET_RF16", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", ",", "flag_pic", "?", "2", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", ",", "(", "arc_tp_regno", "!=", "-", "1", ")", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", ",", "TARGET_NO_SDATA_SET", "?", "0", ":", "2", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", ",", "TARGET_OPTFPE", "?", "1", ":", "0", ")", ";", "if", "(", "TARGET_V2", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", ",", "(", "arc_tune", "<", "ARC_TUNE_CORE_3", ")", "?", "2", ":", "(", "arc_tune", "==", "ARC_TUNE_CORE_3", "?", "3", ":", "4", ")", ")", ";", "}", "</s>" ]

[ "Set", "the", "cpu", "type", "and", "print", "out", "other", "fancy", "things", ",", "at", "the", "top", "of", "the", "file", "." ]

[ "arc", "\"\\t.cpu %s\\n\"", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", "2", "0", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", "1", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", "0", "2", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", "2", "3", "4" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "unsigned", "Directive", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR6", "||", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "CurSlots", "==", "6", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "CurGroup", ".", "push_back", "(", "nullptr", ")", ";", "++", "CurSlots", ";", "}", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR6", "PPC::DIR_PWR7", "6", "0" ]

[]

[ "<s>", "FastISel", "*", "MipsTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ")", ";", "bool", "UseFastISel", "=", "TM", ".", "Options", ".", "EnableFastISel", "&&", "Subtarget", ".", "hasMips32", "(", ")", "&&", "!", "Subtarget", ".", "hasMips32r6", "(", ")", "&&", "!", "Subtarget", ".", "inMips16Mode", "(", ")", "&&", "!", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "if", "(", "!", "TM", ".", "isPositionIndependent", "(", ")", "||", "!", "TM", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "||", "Subtarget", ".", "useXGOT", "(", ")", ")", "UseFastISel", "=", "false", ";", "return", "UseFastISel", "?", "Mips", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ":", "nullptr", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::createFastISel" ]

[]

[ "<s>", "MachineBasicBlock", "*", "getMBB", "(", ")", "const", "{", "return", "MBB", ";", "}", "</s>" ]

[ "Return", "a", "reference", "to", "the", "basic", "block", "containing", "this", "bundle", "." ]

[ "Patmos" ]

[]

[ "<s>", "enum", "reg_class", "avr_regno_reg_class", "(", "int", "r", ")", "{", "static", "const", "enum", "reg_class", "reg_class_tab", "[", "]", "=", "{", "R0_REG", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "ADDW_REGS", ",", "ADDW_REGS", ",", "POINTER_X_REGS", ",", "POINTER_X_REGS", ",", "POINTER_Y_REGS", ",", "POINTER_Y_REGS", ",", "POINTER_Z_REGS", ",", "POINTER_Z_REGS", ",", "STACK_REG", ",", "STACK_REG", "}", ";", "if", "(", "r", "<=", "33", ")", "return", "reg_class_tab", "[", "r", "]", ";", "if", "(", "r", "==", "REG_CC", ")", "return", "CC_REG", ";", "return", "ALL_REGS", ";", "}", "</s>" ]

[ "Return", "register", "class", "for", "register", "R" ]

[ "avr", "33" ]

[]

[ "<s>", "static", "rtx", "loongarch_force_address", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "loongarch_legitimate_address_p", "(", "mode", ",", "x", ",", "false", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "If", "X", "is", "not", "a", "valid", "address", "for", "mode", "MODE", ",", "force", "it", "into", "a", "register", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "char", "*", "output_move_double", "(", "rtx", "operands", "[", "]", ",", "rtx", "insn", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "\"#\"", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "dest_regno", "-", "GPR_FIRST", ")", "&", "1", ")", "==", "0", "&&", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "\"movfgd %1, %0\"", ";", "return", "\"#\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "src", ",", "mode", ")", ")", "return", "\"ldd%I1%U1 %M1, %0\"", ";", "return", "\"#\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "return", "\"#\"", ";", "}", "else", "if", "(", "FPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "dest_regno", "-", "FPR_FIRST", ")", "&", "1", ")", "==", "0", "&&", "(", "(", "src_regno", "-", "GPR_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "\"movgfd %1, %0\"", ";", "return", "\"#\"", ";", "}", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "TARGET_DOUBLE", "&&", "(", "(", "dest_regno", "-", "FPR_FIRST", ")", "&", "1", ")", "==", "0", "&&", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "\"fmovd %1, %0\"", ";", "return", "\"#\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "src", ",", "mode", ")", ")", "return", "\"lddf%I1%U1 %M1, %0\"", ";", "return", "\"#\"", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "\"#\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "src_regno", "-", "GPR_FIRST", ")", "&", "1", ")", "==", "0", "&&", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "\"std%I0%U0 %1, %M0\"", ";", "return", "\"#\"", ";", "}", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "1", ")", "==", "0", "&&", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "\"stdf%I0%U0 %1, %M0\"", ";", "return", "\"#\"", ";", "}", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "\"std%I0%U0 %., %M0\"", ";", "return", "\"#\"", ";", "}", "}", "fatal_insn", "(", "\"bad output_move_double operand\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "appropriate", "code", "to", "load", "up", "an", "8", "byte", "integer", "or", "floating", "point", "value" ]

[ "frv", "0", "1", "\"#\"", "1", "0", "1", "0", "\"movfgd %1, %0\"", "\"#\"", "\"ldd%I1%U1 %M1, %0\"", "\"#\"", "\"#\"", "1", "0", "1", "0", "\"movgfd %1, %0\"", "\"#\"", "1", "0", "1", "0", "\"fmovd %1, %0\"", "\"#\"", "\"lddf%I1%U1 %M1, %0\"", "\"#\"", "\"#\"", "1", "0", "\"std%I0%U0 %1, %M0\"", "\"#\"", "1", "0", "\"stdf%I0%U0 %1, %M0\"", "\"#\"", "\"std%I0%U0 %., %M0\"", "\"#\"", "\"bad output_move_double operand\"", "\"\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitTableType", "(", "const", "MCSymbolWasm", "*", "Sym", ")", "{", "assert", "(", "Sym", "->", "isTable", "(", ")", ")", ";", "const", "wasm", "::", "WasmTableType", "&", "Type", "=", "Sym", "->", "getTableType", "(", ")", ";", "OS", "<<", "\"\\t.tabletype\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\", \"", "<<", "WebAssembly", "::", "typeToString", "(", "static_cast", "<", "wasm", "::", "ValType", ">", "(", "Type", ".", "ElemType", ")", ")", ";", "bool", "HasMaximum", "=", "Type", ".", "Limits", ".", "Flags", "&", "wasm", "::", "WASM_LIMITS_FLAG_HAS_MAX", ";", "if", "(", "Type", ".", "Limits", ".", "Minimum", "!=", "0", "||", "HasMaximum", ")", "{", "OS", "<<", "\", \"", "<<", "Type", ".", "Limits", ".", "Minimum", ";", "if", "(", "HasMaximum", ")", "OS", "<<", "\", \"", "<<", "Type", ".", "Limits", ".", "Maximum", ";", "}", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

[ ".tabletype" ]

[ "WebAssembly", "WebAssembly", "wasm::WasmTableType", "\"\\t.tabletype\\t\"", "\", \"", "WebAssembly::typeToString", "wasm::ValType", "wasm::WASM_LIMITS_FLAG_HAS_MAX", "0", "\", \"", "\", \"" ]

[]

[ "<s>", "static", "tree", "sh_handle_sp_switch_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute argument not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "sp_switch", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qE attribute only applies to functions\"", "\"%qE attribute argument not a string constant\"" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumExplicitOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "APFloat", "&", "FloatValue", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "assert", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEsingle", "&&", "\"Only floating point immediates are supported at the moment.\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "FloatValue", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "0", "\"unknown operand type\"", "\"Only floating point immediates are supported at the moment.\"" ]

[]

[ "<s>", "void", "prepare", "(", ")", "{", "assert", "(", "RS", "&&", "\"Cannot spill SGPR to memory without RegScavenger\"", ")", ";", "TmpVGPR", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MI", ",", "0", ",", "false", ")", ";", "TmpVGPRIndex", "=", "MFI", ".", "getScavengeFI", "(", "MF", ".", "getFrameInfo", "(", ")", ",", "TRI", ")", ";", "if", "(", "TmpVGPR", ")", "{", "TmpVGPRLive", "=", "false", ";", "}", "else", "{", "TmpVGPR", "=", "AMDGPU", "::", "VGPR0", ";", "TmpVGPRLive", "=", "true", ";", "}", "assert", "(", "!", "SavedExecReg", "&&", "\"Exec is already saved, refuse to save again\"", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "IsWave32", "?", "AMDGPU", "::", "SGPR_32RegClass", ":", "AMDGPU", "::", "SGPR_64RegClass", ";", "RS", "->", "setRegUsed", "(", "SuperReg", ")", ";", "SavedExecReg", "=", "RS", "->", "scavengeRegister", "(", "&", "RC", ",", "MI", ",", "0", ",", "false", ")", ";", "int64_t", "VGPRLanes", "=", "getPerVGPRData", "(", ")", ".", "VGPRLanes", ";", "if", "(", "SavedExecReg", ")", "{", "RS", "->", "setRegUsed", "(", "SavedExecReg", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "SavedExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "auto", "I", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MovOpc", ")", ",", "ExecReg", ")", ".", "addImm", "(", "VGPRLanes", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "else", "{", "if", "(", "TmpVGPRLive", ")", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ",", "false", ")", ";", "auto", "I", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "NotOpc", ")", ",", "ExecReg", ")", ".", "addReg", "(", "ExecReg", ")", ";", "if", "(", "!", "TmpVGPRLive", ")", "I", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "ImplicitDefine", ")", ";", "TRI", ".", "buildVGPRSpillLoadStore", "(", "*", "this", ",", "TmpVGPRIndex", ",", "0", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "prepare", "-", "Reset", "state", "and", "prepare", "for", "a", "new", "spill", "placement", "computation", "." ]

[ "AMDGPU", "\"Cannot spill SGPR to memory without RegScavenger\"", "AMDGPU::VGPR_32RegClass", "0", "AMDGPU::VGPR0", "\"Exec is already saved, refuse to save again\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_64RegClass", "0", "0", "0", "0" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "SNES" ]

[]

[ "<s>", "static", "int", "nds32_force_addi_stack_int", "(", "int", "full_value", ")", "{", "int", "adjust_value", ";", "rtx", "tmp_reg", ";", "rtx", "sp_adjust_insn", ";", "if", "(", "!", "satisfies_constraint_Is15", "(", "GEN_INT", "(", "full_value", ")", ")", ")", "{", "tmp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "TA_REGNUM", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "GEN_INT", "(", "full_value", ")", ")", ";", "sp_adjust_insn", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp_reg", ")", ";", "sp_adjust_insn", "=", "emit_insn", "(", "sp_adjust_insn", ")", ";", "if", "(", "full_value", "<", "0", ")", "{", "rtx", "plus_rtx", ";", "rtx", "set_rtx", ";", "plus_rtx", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "full_value", ")", ";", "set_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_rtx", ")", ";", "add_reg_note", "(", "sp_adjust_insn", ",", "REG_FRAME_RELATED_EXPR", ",", "set_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "sp_adjust_insn", ")", "=", "1", ";", "}", "return", "0", ";", "}", "else", "{", "adjust_value", "=", "(", "full_value", "<", "0", ")", "?", "(", "-", "full_value", ")", ":", "(", "full_value", ")", ";", "return", "adjust_value", ";", "}", "}", "</s>" ]

[ "Function", "that", "may", "creates", "more", "instructions", "for", "large", "value", "on", "adjusting", "stack", "pointer", ".", "In", "nds32", "target", ",", "'addi", "'", "can", "be", "used", "for", "stack", "pointer", "adjustment", "in", "prologue/epilogue", "stage", ".", "However", ",", "sometimes", "there", "are", "too", "many", "local", "variables", "so", "that", "the", "adjustment", "value", "is", "not", "able", "to", "be", "fit", "in", "the", "'addi", "'", "instruction", ".", "One", "solution", "is", "to", "move", "value", "into", "a", "register", "and", "then", "use", "'add", "'", "instruction", ".", "In", "practice", ",", "we", "use", "TA_REGNUM", "(", "$", "r15", ")", "to", "accomplish", "this", "purpose", ".", "Also", ",", "we", "need", "to", "return", "zero", "for", "sp", "adjustment", "so", "that", "proglogue/epilogue", "knows", "there", "is", "no", "need", "to", "create", "'addi", "'", "instruction", "." ]

[ "nds32", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "mergeStoresAfterLegalization", "(", "EVT", "VT", ")", "const", "{", "return", "!", "Subtarget", ".", "useRVVForFixedLengthVectors", "(", ")", "||", "(", "VT", ".", "isFixedLengthVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", ";", "}", "</s>" ]

[ "Do", "not", "merge", "vector", "stores", "after", "legalization", "because", "that", "may", "conflict", "with", "x86-specific", "store", "splitting", "optimizations", "." ]

[ "RISCV", "RISCV", "MVT::i1" ]

[]

[ "<s>", "static", "bool", "isConditionalBranch", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "false", ";", "case", "ARM64", "::", "TBZ", ":", "case", "ARM64", "::", "TBNZ", ":", "case", "ARM64", "::", "CBZW", ":", "case", "ARM64", "::", "CBNZW", ":", "case", "ARM64", "::", "CBZX", ":", "case", "ARM64", "::", "CBNZX", ":", "case", "ARM64", "::", "Bcc", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "ARM64", "ARM64::TBZ", "ARM64::TBNZ", "ARM64::CBZW", "ARM64::CBNZW", "ARM64::CBZX", "ARM64::CBNZX", "ARM64::Bcc" ]

[]

[ "<s>", "static", "bool", "spe_func_has_64bit_regs_p", "(", "void", ")", "{", "rtx_insn", "*", "insns", ",", "*", "insn", ";", "if", "(", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "calls_setjmp", "||", "crtl", "->", "has_nonlocal_goto", ")", "return", "true", ";", "insns", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "insns", ")", ";", "insn", "!=", "NULL_RTX", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "i", ";", "i", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "i", ")", "==", "SET", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "SET_SRC", "(", "i", ")", ")", ";", "if", "(", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_E500_DOUBLE", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "TFmode", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "uses", "any", "GPRs", "in", "64-bit", "SIMD", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "TGSIInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "mi", ",", "int", "&", "fi", ")", "const", "{", "if", "(", "(", "mi", "->", "getOpcode", "(", ")", "==", "TGSI", "::", "LDpis", "||", "mi", "->", "getOpcode", "(", ")", "==", "TGSI", "::", "LDpfs", "||", "mi", "->", "getOpcode", "(", ")", "==", "TGSI", "::", "LDpiv", "||", "mi", "->", "getOpcode", "(", ")", "==", "TGSI", "::", "LDpfv", ")", "&&", "mi", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "fi", "=", "mi", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "mi", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI::LDpis", "TGSI::LDpfs", "TGSI::LDpiv", "TGSI::LDpfv", "1", "1", "0", "0" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "if", "(", "Size", ">", "HEXAGON_MAX_PACKET_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "auto", "ArchSTI", "=", "Hexagon_MC", "::", "getArchSubtarget", "(", "&", "STI", ")", ";", "const", "auto", "STI_", "=", "(", "ArchSTI", "!=", "nullptr", ")", "?", "*", "ArchSTI", ":", "STI", ";", "HexagonMCChecker", "Checker", "(", "getContext", "(", ")", ",", "*", "MCII", ",", "STI_", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "remapInstruction", "(", "MI", ")", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Constant Islands\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Constant Islands\"" ]

[]

[ "<s>", "bool", "AMDGPUIntrinsicInfo", "::", "isOverloaded", "(", "unsigned", "id", ")", "const", "{", "}", "</s>" ]

[ "Returns", "true", "if", "the", "intrinsic", "can", "be", "overloaded", "." ]

[ "R600" ]

[]

[ "<s>", "void", "PatmosLatencyQueue", "::", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"PendingQueue:\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "PendingQueue", ".", "size", "(", ")", ";", "i", "++", ")", "{", "SUnit", "*", "SU", "=", "PendingQueue", "[", "i", "]", ";", "if", "(", "i", ">", "0", ")", "dbgs", "(", ")", "<<", "\",\"", ";", "dbgs", "(", ")", "<<", "\" SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\"): Height \"", "<<", "SU", "->", "getHeight", "(", ")", "<<", "\" Depth \"", "<<", "SU", "->", "getDepth", "(", ")", "<<", "\" Tree: \"", "<<", "Cmp", ".", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", "<<", "\" @\"", "<<", "Cmp", ".", "DFSResult", "->", "getSubtreeLevel", "(", "Cmp", ".", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", ")", ";", "if", "(", "SU", "->", "isScheduleLow", ")", "dbgs", "(", ")", "<<", "\" low \"", ";", "}", "dbgs", "(", ")", "<<", "\"\\nAvailableQueue:\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "AvailableQueue", ".", "size", "(", ")", ";", "i", "++", ")", "{", "SUnit", "*", "SU", "=", "AvailableQueue", "[", "i", "]", ";", "if", "(", "i", ">", "0", ")", "dbgs", "(", ")", "<<", "\",\"", ";", "dbgs", "(", ")", "<<", "\" SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") Height \"", "<<", "SU", "->", "getHeight", "(", ")", "<<", "\" Depth \"", "<<", "SU", "->", "getDepth", "(", ")", "<<", "\" ILP: \"", "<<", "Cmp", ".", "DFSResult", "->", "getILP", "(", "SU", ")", ";", "if", "(", "SU", "->", "isScheduleLow", ")", "dbgs", "(", ")", "<<", "\" low \"", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"PendingQueue:\"", "0", "0", "\",\"", "\" SU(\"", "\"): Height \"", "\" Depth \"", "\" Tree: \"", "\" @\"", "\" low \"", "\"\\nAvailableQueue:\"", "0", "0", "\",\"", "\" SU(\"", "\") Height \"", "\" Depth \"", "\" ILP: \"", "\" low \"", "\"\\n\"" ]

[]

[ "<s>", "SDNode", "*", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "SelectAdd", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "SelectMul", "(", "N", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "return", "SelectBitOp", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SelectIntrinsicWChain", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::FABS", "ISD::FNEG", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "static", "char", "nds32_byte_to_size", "(", "int", "byte", ")", "{", "switch", "(", "byte", ")", "{", "case", "4", ":", "return", "'w'", ";", "case", "2", ":", "return", "'h'", ";", "case", "1", ":", "return", "'b'", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "A", "helper", "function", "to", "return", "character", "based", "on", "byte", "size", "." ]

[ "nds32", "4", "2", "1" ]

[]

[ "<s>", "void", "NVPTXInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "unsigned", "RCId", "=", "(", "RegNo", ">>", "28", ")", ";", "switch", "(", "RCId", ")", "{", "default", ":", "report_fatal_error", "(", "\"Bad virtual register encoding\"", ")", ";", "case", "0", ":", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "return", ";", "case", "1", ":", "OS", "<<", "\"%p\"", ";", "break", ";", "case", "2", ":", "OS", "<<", "\"%rs\"", ";", "break", ";", "case", "3", ":", "OS", "<<", "\"%r\"", ";", "break", ";", "case", "4", ":", "OS", "<<", "\"%rd\"", ";", "break", ";", "case", "5", ":", "OS", "<<", "\"%f\"", ";", "break", ";", "case", "6", ":", "OS", "<<", "\"%fd\"", ";", "break", ";", "case", "7", ":", "OS", "<<", "\"%h\"", ";", "break", ";", "case", "8", ":", "OS", "<<", "\"%hh\"", ";", "break", ";", "}", "unsigned", "VReg", "=", "RegNo", "&", "0x0FFFFFFF", ";", "OS", "<<", "VReg", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "28", "\"Bad virtual register encoding\"", "0", "1", "\"%p\"", "2", "\"%rs\"", "3", "\"%r\"", "4", "\"%rd\"", "5", "\"%f\"", "6", "\"%fd\"", "7", "\"%h\"", "8", "\"%hh\"", "0x0FFFFFFF" ]

[]

[ "<s>", "static", "void", "epiphany_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "machine_function_t", "*", "mf", "=", "MACHINE_FUNCTION", "(", "cfun", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "gcc_assert", "(", "arg", ".", "mode", "!=", "BLKmode", ")", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "next_cum", "=", "(", "ROUND_ADVANCE_CUM", "(", "next_cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "first_anon_arg", "<", "MAX_EPIPHANY_PARM_REGS", "&&", "!", "no_rtl", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "*", "pretend_size", "=", "(", "(", "MAX_EPIPHANY_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "mf", "->", "args_parsed", "=", "1", ";", "mf", "->", "pretend_args_odd", "=", "(", "(", "*", "pretend_size", "&", "UNITS_PER_WORD", ")", "?", "1", ":", "0", ")", ";", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "EPIPHANY", ",", "we", "actually", "emit", "the", "code", "in", "epiphany_expand_prologue", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "epiphany", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "arm_option_restore", "(", "struct", "gcc_options", "*", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "arm_configure_build_target", "(", "&", "arm_active_target", ",", "ptr", ",", "&", "global_options_set", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_RESTORE", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "need_to_save", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "is_interrupt_func", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "regno", "<", "8", ")", "return", "true", ";", "if", "(", "regno", ">", "23", ")", "return", "false", ";", "if", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "regno", "<", "22", ")", "return", "true", ";", "return", "df_regs_ever_live_p", "(", "regno", ")", ";", "}", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "&&", "(", "frame_pointer_needed", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", ")", "return", "true", ";", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "true", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "given", "register", "needs", "to", "be", "saved", "by", "the", "current", "function", "." ]

[ "rl78", "8", "23", "22" ]

[]

[ "<s>", "static", "int", "ix86_enum_va_list", "(", "int", "idx", ",", "const", "char", "*", "*", "pname", ",", "tree", "*", "ptree", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "switch", "(", "idx", ")", "{", "default", ":", "break", ";", "case", "0", ":", "*", "ptree", "=", "ms_va_list_type_node", ";", "*", "pname", "=", "\"__builtin_ms_va_list\"", ";", "return", "1", ";", "case", "1", ":", "*", "ptree", "=", "sysv_va_list_type_node", ";", "*", "pname", "=", "\"__builtin_sysv_va_list\"", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Iterate", "through", "the", "target-specific", "builtin", "types", "for", "va_list", ".", "IDX", "denotes", "the", "iterator", ",", "*", "PTREE", "is", "set", "to", "the", "result", "type", "of", "the", "va_list", "builtin", ",", "and", "*", "PNAME", "to", "its", "internal", "type", ".", "Returns", "zero", "if", "there", "is", "no", "element", "for", "this", "index", ",", "otherwise", "IDX", "should", "be", "increased", "upon", "the", "next", "call", ".", "Note", ",", "do", "not", "iterate", "a", "base", "builtin", "'s", "name", "like", "__builtin_va_list", ".", "Used", "from", "c_common_nodes_and_builtins", "." ]

[ "i386", "0", "\"__builtin_ms_va_list\"", "1", "1", "\"__builtin_sysv_va_list\"", "1", "0" ]

[]

[ "<s>", "EVT", "SICTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i24", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "MVT::i24" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ")", "{", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "X86FI", "||", "X86FI", "->", "getUsesRedZone", "(", ")", ")", "return", "false", ";", "}", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "MVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "VT", ")", "||", "isSHUFPMask", "(", "M", ",", "VT", ")", "||", "isPSHUFDMask", "(", "M", ",", "VT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "VT", ")", "||", "isPSHUFLWMask", "(", "M", ",", "VT", ")", "||", "isUNPCKLMask", "(", "M", ",", "VT", ")", "||", "isUNPCKHMask", "(", "M", ",", "VT", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "VT", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "VT", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "64", "2", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "32", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

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

[]

[ "<s>", "void", "rs6000_expand_extract_even", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "vec_perm_builder", "perm", "(", "nelt", ",", "nelt", ",", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "perm", ".", "quick_push", "(", "i", "*", "2", ")", ";", "rs6000_do_expand_vec_perm", "(", "target", ",", "op0", ",", "op1", ",", "vmode", ",", "perm", ")", ";", "}", "</s>" ]

[ "Expand", "an", "extract", "even", "operation", "." ]

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

[]

[ "<s>", "const", "char", "*", "standard_sse_constant_opcode", "(", "rtx_insn", "*", "insn", ",", "rtx", "x", ")", "{", "switch", "(", "standard_sse_constant_p", "(", "x", ")", ")", "{", "case", "1", ":", "switch", "(", "get_attr_mode", "(", "insn", ")", ")", "{", "case", "MODE_XI", ":", "return", "\"vpxord\\t%g0, %g0, %g0\"", ";", "case", "MODE_V16SF", ":", "return", "TARGET_AVX512DQ", "?", "\"vxorps\\t%g0, %g0, %g0\"", ":", "\"vpxord\\t%g0, %g0, %g0\"", ";", "case", "MODE_V8DF", ":", "return", "TARGET_AVX512DQ", "?", "\"vxorpd\\t%g0, %g0, %g0\"", ":", "\"vpxorq\\t%g0, %g0, %g0\"", ";", "case", "MODE_TI", ":", "return", "TARGET_AVX512VL", "?", "\"vpxord\\t%t0, %t0, %t0\"", ":", "\"%vpxor\\t%0, %d0\"", ";", "case", "MODE_V2DF", ":", "return", "\"%vxorpd\\t%0, %d0\"", ";", "case", "MODE_V4SF", ":", "return", "\"%vxorps\\t%0, %d0\"", ";", "case", "MODE_OI", ":", "return", "TARGET_AVX512VL", "?", "\"vpxord\\t%x0, %x0, %x0\"", ":", "\"vpxor\\t%x0, %x0, %x0\"", ";", "case", "MODE_V4DF", ":", "return", "\"vxorpd\\t%x0, %x0, %x0\"", ";", "case", "MODE_V8SF", ":", "return", "\"vxorps\\t%x0, %x0, %x0\"", ";", "default", ":", "break", ";", "}", "case", "2", ":", "if", "(", "TARGET_AVX512VL", "||", "get_attr_mode", "(", "insn", ")", "==", "MODE_XI", "||", "get_attr_mode", "(", "insn", ")", "==", "MODE_V8DF", "||", "get_attr_mode", "(", "insn", ")", "==", "MODE_V16SF", ")", "return", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", ";", "if", "(", "TARGET_AVX", ")", "return", "\"vpcmpeqd\\t%0, %0, %0\"", ";", "else", "return", "\"pcmpeqd\\t%0, %0\"", ";", "default", ":", "break", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "opcode", "of", "the", "special", "instruction", "to", "be", "used", "to", "load", "the", "constant", "X", "." ]

[ "i386", "1", "\"vpxord\\t%g0, %g0, %g0\"", "\"vxorps\\t%g0, %g0, %g0\"", "\"vpxord\\t%g0, %g0, %g0\"", "\"vxorpd\\t%g0, %g0, %g0\"", "\"vpxorq\\t%g0, %g0, %g0\"", "\"vpxord\\t%t0, %t0, %t0\"", "\"%vpxor\\t%0, %d0\"", "\"%vxorpd\\t%0, %d0\"", "\"%vxorps\\t%0, %d0\"", "\"vpxord\\t%x0, %x0, %x0\"", "\"vpxor\\t%x0, %x0, %x0\"", "\"vxorpd\\t%x0, %x0, %x0\"", "\"vxorps\\t%x0, %x0, %x0\"", "2", "\"vpternlogd\\t{$0xFF, %g0, %g0, %g0|%g0, %g0, %g0, 0xFF}\"", "\"vpcmpeqd\\t%0, %0, %0\"", "\"pcmpeqd\\t%0, %0\"" ]

[]

[ "<s>", "int", "frv_issue_rate", "(", "void", ")", "{", "if", "(", "!", "TARGET_PACK", ")", "return", "1", ";", "switch", "(", "frv_cpu_type", ")", "{", "default", ":", "case", "FRV_CPU_FR300", ":", "case", "FRV_CPU_SIMPLE", ":", "return", "1", ";", "case", "FRV_CPU_FR400", ":", "case", "FRV_CPU_FR405", ":", "case", "FRV_CPU_FR450", ":", "return", "2", ";", "case", "FRV_CPU_GENERIC", ":", "case", "FRV_CPU_FR500", ":", "case", "FRV_CPU_TOMCAT", ":", "return", "4", ";", "case", "FRV_CPU_FR550", ":", "return", "8", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_ISSUE_RATE", "." ]

[ "frv", "1", "1", "2", "4", "8" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "(", "ScalarVT", "==", "MVT", "::", "f32", "||", "ScalarVT", "==", "MVT", "::", "f64", "||", "(", "ScalarVT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

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

[]

[ "<s>", "bool", "doInitialization", "(", "Loop", "*", "L", ",", "LPPassManager", "&", "LPM", ")", "override", "{", "LoadPairs", ".", "clear", "(", ")", ";", "WideLoads", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "RISCVAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Kind", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ",", "8", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "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", "." ]

[ "RI5CY", "RISCV", "8", "8", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "std", "::", "string", "Str", ";", "raw_string_ostream", "OS", "(", "Str", ")", ";", "if", "(", "DLoc", ")", "{", "auto", "DIL", "=", "DLoc", ".", "get", "(", ")", ";", "StringRef", "Filename", "=", "DIL", "->", "getFilename", "(", ")", ";", "unsigned", "Line", "=", "DIL", "->", "getLine", "(", ")", ";", "unsigned", "Column", "=", "DIL", "->", "getColumn", "(", ")", ";", "OS", "<<", "Filename", "<<", "':'", "<<", "Line", "<<", "':'", "<<", "Column", "<<", "' '", ";", "}", "OS", "<<", "\"in function \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "' '", "<<", "*", "Fn", ".", "getFunctionType", "(", ")", "<<", "'\\n'", "<<", "Description", ";", "if", "(", "Value", ")", "Value", "->", "print", "(", "OS", ")", ";", "OS", "<<", "'\\n'", ";", "OS", ".", "flush", "(", ")", ";", "DP", "<<", "Str", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"in function \"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "EVT", "SrcVT", "=", "ExtVal", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "if", "(", "SrcVT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "X86", "X86", "0", "MVT::i1" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindTy", "::", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "RI5CY" ]

[]

[ "<s>", "Register", "CSKYTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "CSKY", "::", "R0", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::R0" ]

[]

[ "<s>", "static", "bool", "symbian_export_vtable_and_rtti_p", "(", "tree", "ctype", ")", "{", "bool", "inline_ctor_dtor", ";", "bool", "dllimport_ctor_dtor", ";", "bool", "dllimport_member", ";", "tree", "binfo", ",", "base_binfo", ";", "VEC", "(", "tree", ",", "gc", ")", "*", "method_vec", ";", "tree", "key", ";", "int", "i", ";", "int", "len", ";", "if", "(", "TREE_CODE", "(", "ctype", ")", "!=", "RECORD_TYPE", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does NOT need to be EXPORTed [not a class]\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "(", "key", "=", "CLASSTYPE_KEY_METHOD", "(", "ctype", ")", ")", "==", "NULL_TREE", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does NOT need to be EXPORTed [no key function]\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "key", ")", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does NOT need to be EXPORTed [key function not defined]\\n\"", ")", ";", "return", "false", ";", "}", "inline_ctor_dtor", "=", "false", ";", "dllimport_ctor_dtor", "=", "false", ";", "dllimport_member", "=", "false", ";", "method_vec", "=", "CLASSTYPE_METHOD_VEC", "(", "ctype", ")", ";", "len", "=", "method_vec", "?", "VEC_length", "(", "tree", ",", "method_vec", ")", ":", "0", ";", "for", "(", ";", "len", "--", ";", ")", "{", "tree", "member", "=", "VEC_index", "(", "tree", ",", "method_vec", ",", "len", ")", ";", "if", "(", "!", "member", ")", "continue", ";", "for", "(", "member", "=", "OVL_CURRENT", "(", "member", ")", ";", "member", ";", "member", "=", "OVL_NEXT", "(", "member", ")", ")", "{", "if", "(", "TREE_CODE", "(", "member", ")", "!=", "FUNCTION_DECL", ")", "continue", ";", "if", "(", "DECL_CONSTRUCTOR_P", "(", "member", ")", "||", "DECL_DESTRUCTOR_P", "(", "member", ")", ")", "{", "if", "(", "DECL_INLINE", "(", "member", ")", "&&", "(", "DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P", "(", "member", ")", "||", "DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P", "(", "member", ")", ")", ")", "inline_ctor_dtor", "=", "true", ";", "if", "(", "lookup_attribute", "(", "\"dllimport\"", ",", "DECL_ATTRIBUTES", "(", "member", ")", ")", ")", "dllimport_ctor_dtor", "=", "true", ";", "}", "else", "{", "if", "(", "DECL_PURE_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "!", "DECL_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "DECL_INLINE", "(", "member", ")", ")", "continue", ";", "if", "(", "lookup_attribute", "(", "\"dllimport\"", ",", "DECL_ATTRIBUTES", "(", "member", ")", ")", ")", "dllimport_member", "=", "true", ";", "}", "}", "}", "if", "(", "!", "dllimport_member", "&&", "!", "dllimport_ctor_dtor", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does NOT need to be EXPORTed [no non-pure virtuals or ctors/dtors with dllimport]\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "inline_ctor_dtor", ")", "{", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" does NOT need to be EXPORTed [no inline ctor/dtor]\\n\"", ")", ";", "return", "false", ";", "}", "print_node_brief", "(", "stderr", ",", "\"\"", ",", "ctype", ",", "0", ")", ";", "fprintf", "(", "stderr", ",", "\" DOES need to be EXPORTed\\n\"", ")", ";", "for", "(", "i", "=", "0", ",", "binfo", "=", "TYPE_BINFO", "(", "ctype", ")", ";", "BINFO_BASE_ITERATE", "(", "binfo", ",", "i", ",", "base_binfo", ")", ";", "i", "++", ")", "symbian_possibly_export_base_class", "(", "BINFO_TYPE", "(", "base_binfo", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Decide", "if", "a", "class", "needs", "its", "vtable", "and", "rtti", "exporting", "." ]

[ "sh", "\"\"", "0", "\" does NOT need to be EXPORTed [not a class]\\n\"", "\"\"", "0", "\" does NOT need to be EXPORTed [no key function]\\n\"", "\"\"", "0", "\" does NOT need to be EXPORTed [key function not defined]\\n\"", "0", "\"dllimport\"", "\"dllimport\"", "\"\"", "0", "\" does NOT need to be EXPORTed [no non-pure virtuals or ctors/dtors with dllimport]\\n\"", "\"\"", "0", "\" does NOT need to be EXPORTed [no inline ctor/dtor]\\n\"", "\"\"", "0", "\" DOES need to be EXPORTed\\n\"", "0" ]

[]