Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "s390_emit_compare", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "s390_select_ccmode", "(", "code", ",", "op0", ",", "op1", ")", ";", "rtx", "cc", ";", "if", "(", "TARGET_VX", "&&", "register_operand", "(", "op0", ",", "DFmode", ")", "&&", "register_operand", "(", "op1", ",", "DFmode", ")", "&&", "s390_expand_vec_compare_scalar", "(", "&", "code", ",", "op0", ",", "op1", ",", "&", "cc", ")", ")", "{", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_CC", ")", "{", "gcc_assert", "(", "s390_cc_modes_compatible", "(", "GET_MODE", "(", "op0", ")", ",", "mode", ")", "==", "GET_MODE", "(", "op0", ")", ")", ";", "cc", "=", "op0", ";", "}", "else", "{", "cc", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc", ",", "gen_rtx_COMPARE", "(", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "compare", "instruction", "suitable", "to", "implement", "the", "comparison", "OP0", "CODE", "OP1", ".", "Return", "the", "correct", "condition", "RTL", "to", "be", "placed", "in", "the", "IF_THEN_ELSE", "of", "the", "conditional", "branch", "testing", "the", "result", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "ix86_reorg", "(", "void", ")", "{", "compute_bb_for_insn", "(", ")", ";", "if", "(", "TARGET_SEH", "&&", "current_function_has_exception_handlers", "(", ")", ")", "ix86_seh_fixup_eh_fallthru", "(", ")", ";", "if", "(", "optimize", "&&", "optimize_function_for_speed_p", "(", "cfun", ")", ")", "{", "if", "(", "TARGET_SSE2", ")", "ix86_split_stlf_stall_load", "(", ")", ";", "if", "(", "TARGET_PAD_SHORT_FUNCTION", ")", "ix86_pad_short_function", "(", ")", ";", "else", "if", "(", "TARGET_PAD_RETURNS", ")", "ix86_pad_returns", "(", ")", ";", "if", "(", "TARGET_FOUR_JUMP_LIMIT", ")", "ix86_avoid_jump_mispredicts", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "machine", "specific", "optimizations", ".", "We", "implement", "padding", "of", "returns", "for", "K8", "CPUs", "and", "pass", "to", "avoid", "4", "jumps", "in", "the", "single", "16", "byte", "window", "." ]

[ "i386" ]

[]

[ "<s>", "void", "Z80oldInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "TRC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "Opc", ";", "switch", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected regclass size\"", ")", ";", "case", "1", ":", "Opc", "=", "Z80old", "::", "LD8ro", ";", "break", ";", "case", "2", ":", "Opc", "=", "Z80old", "::", "LD88ro", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "unsigned", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ";", "bool", "Split", "=", "Z80old", "::", "splitReg", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ",", "Z80old", "::", "LD8ro", ",", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ")", ";", "MachineInstrBuilder", "LoMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "LoOpc", ")", ")", ",", "DstReg", ",", "LoIdx", ",", "TRI", ",", "RegState", "::", "DefineNoRead", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "Split", ")", "{", "MachineInstrBuilder", "HiMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "HiOpc", ")", ")", ",", "DstReg", ",", "HiIdx", ",", "TRI", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "HiOff", ")", ";", "HiMIB", "->", "addRegisterDefined", "(", "DstReg", ",", "TRI", ")", ";", "}", "}", "</s>" ]

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

[ "Z80old", "Z80old", "\"Unexpected regclass size\"", "1", "Z80old::LD8ro", "2", "Z80old::LD88ro", "0", "Z80old::splitReg", "Z80old::LD8ro", "0" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "&", "getPPCTargetMachine", "(", ")", ")", ")", ";", "bool", "UsePrefetching", "=", "Triple", "(", "TM", "->", "getTargetTriple", "(", ")", ")", ".", "getVendor", "(", ")", "==", "Triple", "::", "BGQ", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "UsePrefetching", "=", "EnablePrefetch", ";", "if", "(", "UsePrefetching", ")", "addPass", "(", "createPPCLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "or1k_expand_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "label", ";", "machine_mode", "mode", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "retval", ",", "val", ")", ")", "val", "=", "copy_to_reg", "(", "val", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_store_conditional", "(", "mode", ",", "mem", ",", "val", ")", ";", "emit_unlikely_jump", "(", "EQ", ",", "label", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "exchange", "operation", ".", "Emits", "the", "RTX", "to", "perform", "an", "exchange", "operation", ".", "This", "function", "takes", "4", "RTX", "arguments", "in", "the", "OPERANDS", "array", ".", "The", "exchange", "operation", "atomically", "loads", "a", "value", "from", "memory", "(", "OPERANDS", "[", "1", "]", ")", "to", "a", "return", "value", "(", "OPERANDS", "[", "0", "]", ")", "and", "stores", "a", "new", "value", "(", "OPERANDS", "[", "2", "]", ")", "back", "to", "the", "memory", "location", ".", "Another", "argument", "(", "OPERANDS", "[", "3", "]", ")", "is", "used", "to", "indicate", "the", "memory", "model", "and", "is", "not", "used", "by", "OpenRISC", ".", "For", "OpenRISC", "this", "emits", "RTX", "which", "will", "translate", "to", "assembly", "using", "the", "'", "l.lwa", "'", "(", "load", "word", "atomic", ")", "and", "'", "l.swa", "'", "(", "store", "word", "atomic", ")", "instructions", "." ]

[ "or1k", "0", "1", "2", "0" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "isHsaAbiVersion3AndAbove", "(", "&", "getSTI", "(", ")", ")", ")", "{", "if", "(", "IDVal", "==", "\".amdhsa_kernel\"", ")", "return", "ParseDirectiveAMDHSAKernel", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "V3", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "else", "{", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_amdgpu_isa\"", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".amdgcn_target\"", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_lds\"", ")", "return", "ParseDirectiveAMDGPULDS", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectivePALMetadataBegin", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\".amdhsa_kernel\"", "AMDGPU::HSAMD", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amd_amdgpu_isa\"", "AMDGPU::HSAMD", "\".amdgcn_target\"", "\".amdgpu_lds\"", "AMDGPU" ]

[]

[ "<s>", "bool", "TPCElfSpecSet", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "!", "EnableElfSpec", ")", "return", "false", ";", "searchInstruction", "(", "Func", ")", ";", "searchPrintF", "(", "Func", ")", ";", "createElfSection", "(", "Func", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "bool", "aarch64_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "if", "(", "sel", ".", "ninputs", "(", ")", "==", "1", "||", "(", "op0", "&&", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", ")", "d", ".", "one_vector_p", "=", "true", ";", "else", "if", "(", "sel", ".", "all_from_input_p", "(", "0", ")", ")", "{", "d", ".", "one_vector_p", "=", "true", ";", "op1", "=", "op0", ";", "}", "else", "if", "(", "sel", ".", "all_from_input_p", "(", "1", ")", ")", "{", "d", ".", "one_vector_p", "=", "true", ";", "op0", "=", "op1", ";", "}", "else", "d", ".", "one_vector_p", "=", "false", ";", "d", ".", "perm", ".", "new_vector", "(", "sel", ".", "encoding", "(", ")", ",", "d", ".", "one_vector_p", "?", "1", ":", "2", ",", "sel", ".", "nelts_per_input", "(", ")", ")", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "d", ".", "vmode", ")", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "testing_p", "=", "!", "target", ";", "if", "(", "!", "d", ".", "testing_p", ")", "return", "aarch64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "rtx_insn", "*", "last", "=", "get_last_insn", "(", ")", ";", "bool", "ret", "=", "aarch64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "gcc_assert", "(", "last", "==", "get_last_insn", "(", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "void", "BTFDebug", "::", "endModule", "(", ")", "{", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "processGlobals", "(", "false", ")", ";", "for", "(", "auto", "&", "DataSec", ":", "DataSecEntries", ")", "addType", "(", "std", "::", "move", "(", "DataSec", ".", "second", ")", ")", ";", "for", "(", "auto", "&", "Fixup", ":", "FixupDerivedTypes", ")", "{", "StringRef", "TypeName", "=", "Fixup", ".", "first", ";", "bool", "IsUnion", "=", "Fixup", ".", "second", ".", "first", ";", "uint32_t", "StructTypeId", "=", "0", ";", "for", "(", "const", "auto", "&", "StructType", ":", "StructTypes", ")", "{", "if", "(", "StructType", "->", "getName", "(", ")", "==", "TypeName", ")", "{", "StructTypeId", "=", "StructType", "->", "getId", "(", ")", ";", "break", ";", "}", "}", "if", "(", "StructTypeId", "==", "0", ")", "{", "auto", "FwdTypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFwd", ">", "(", "TypeName", ",", "IsUnion", ")", ";", "StructTypeId", "=", "addType", "(", "std", "::", "move", "(", "FwdTypeEntry", ")", ")", ";", "}", "for", "(", "auto", "&", "DType", ":", "Fixup", ".", "second", ".", "second", ")", "{", "DType", "->", "setPointeeType", "(", "StructTypeId", ")", ";", "}", "}", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "emitBTFSection", "(", ")", ";", "emitBTFExtSection", "(", ")", ";", "}", "</s>" ]

[ "Emit", "all", "exception", "information", "that", "should", "come", "after", "the", "content", "." ]

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

[]

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

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

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

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "ARMBaseInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "ARMII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_LO16", ",", "\"arm-lo16\"", "}", ",", "{", "MO_HI16", ",", "\"arm-hi16\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "ARM", "ARM", "ARM", "\"arm-lo16\"", "\"arm-hi16\"" ]

[]

[ "<s>", "void", "AArch64TTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "if", "(", "L", "->", "getLoopDepth", "(", ")", ">", "1", ")", "UP", ".", "PartialThreshold", "*=", "2", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "ST", "->", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "Falkor", "&&", "EnableFalkorHWPFUnrollFix", ")", "getFalkorUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "}", "}", "if", "(", "ST", "->", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Others", "&&", "!", "ST", "->", "getSchedModel", "(", ")", ".", "isOutOfOrder", "(", ")", ")", "{", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "if", "(", "MCID", ".", "getSize", "(", ")", ")", "return", "MCID", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "INLINEASM", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "MAI", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleLength", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "GC_LABEL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "AArch64", "::", "TLSDESCCALL", ":", "return", "0", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction class\"", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::INLINEASM", "0", "AArch64::TLSDESCCALL", "0", "\"Unknown instruction class\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "}", "}", "else", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_RESTORE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_RESTORE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "1", "8", "32", "AMDGPU::SI_SPILL_S32_RESTORE", "64", "AMDGPU::SI_SPILL_S64_RESTORE", "128", "AMDGPU::SI_SPILL_S128_RESTORE", "256", "AMDGPU::SI_SPILL_S256_RESTORE", "512", "AMDGPU::SI_SPILL_S512_RESTORE", "8", "32", "AMDGPU::SI_SPILL_V32_RESTORE", "64", "AMDGPU::SI_SPILL_V64_RESTORE", "96", "AMDGPU::SI_SPILL_V96_RESTORE", "128", "AMDGPU::SI_SPILL_V128_RESTORE", "256", "AMDGPU::SI_SPILL_V256_RESTORE", "512", "AMDGPU::SI_SPILL_V512_RESTORE", "1", "4", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR0", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", "AMDGPU::IMPLICIT_DEF" ]

[]

[ "<s>", "bool", "aarch64_sve_addvl_addpl_immediate_p", "(", "rtx", "x", ")", "{", "poly_int64", "value", ";", "return", "(", "poly_int_rtx_p", "(", "x", ",", "&", "value", ")", "&&", "aarch64_sve_addvl_addpl_immediate_p", "(", "value", ")", ")", ";", "}", "</s>" ]

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

[ "aarch64" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "PPCTargetMachine", "&", "TM", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "IsPPC64", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", "||", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "PPCCallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "PPCLegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "PPCRegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createPPCInstructionSelector", "(", "*", "static_cast", "<", "const", "PPCTargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmit_i", "(", "MVT", "Ty", ",", "MVT", "VT", ",", "unsigned", "Opc", ",", "uint64_t", "Imm", ")", "{", "if", "(", "Opc", "!=", "ISD", "::", "Constant", ")", "return", "0", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "PPCSubTarget", "->", "useCRBits", "(", ")", ")", "{", "unsigned", "ImmReg", "=", "createResultReg", "(", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Imm", "==", "0", "?", "PPC", "::", "CRUNSET", ":", "PPC", "::", "CRSET", ")", ",", "ImmReg", ")", ";", "return", "ImmReg", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", "&&", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i1", ")", "return", "0", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "(", "VT", "==", "MVT", "::", "i64", ")", "?", "&", "PPC", "::", "G8RCRegClass", ":", "&", "PPC", "::", "GPRCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "PPCMaterialize64BitInt", "(", "Imm", ",", "RC", ")", ";", "else", "return", "PPCMaterialize32BitInt", "(", "Imm", ",", "RC", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "request", "that", "an", "instruction", "with", "the", "given", "type", ",", "opcode", ",", "and", "immediate", "operand", "be", "emitted", "." ]

[ "PowerPC", "PPC", "ISD::Constant", "0", "MVT::i1", "PPC", "PPC::CRBITRCRegClass", "0", "PPC::CRUNSET", "PPC::CRSET", "MVT::i64", "MVT::i32", "MVT::i16", "MVT::i8", "MVT::i1", "0", "MVT::i64", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "MVT::i64", "PPC", "PPC" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "override", "{", "if", "(", "!", "VT", ".", "isScalableVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "PowerPC", "1", "8", "0" ]

[]

[ "<s>", "bool", "sh_movsf_ie_ra_split_p", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_DOUBLE", "&&", "!", "satisfies_constraint_G", "(", "op1", ")", "&&", "!", "satisfies_constraint_H", "(", "op1", ")", "&&", "REG_P", "(", "op0", ")", "&&", "REG_P", "(", "op2", ")", ")", "return", "true", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "FP_REGISTER_P", "(", "REGNO", "(", "op0", ")", ")", "&&", "REG_P", "(", "op1", ")", "&&", "GENERAL_REGISTER_P", "(", "REGNO", "(", "op1", ")", ")", "&&", "REG_P", "(", "op2", ")", "&&", "(", "REGNO", "(", "op2", ")", "==", "FPUL_REG", ")", ")", "return", "true", ";", "if", "(", "REG_P", "(", "op1", ")", "&&", "FP_REGISTER_P", "(", "REGNO", "(", "op1", ")", ")", "&&", "REG_P", "(", "op0", ")", "&&", "GENERAL_REGISTER_P", "(", "REGNO", "(", "op0", ")", ")", "&&", "REG_P", "(", "op2", ")", "&&", "(", "REGNO", "(", "op2", ")", "==", "FPUL_REG", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "movsf", "insn", "should", "be", "splited", "with", "an", "additional", "register", "." ]

[ "sh" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "if", "(", "Is64Bit", ")", "{", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "TFI", "->", "Uses64BitFramePtr", "?", "&", "X86", "::", "LOW32_ADDR_ACCESS_RBPRegClass", ":", "&", "X86", "::", "LOW32_ADDR_ACCESSRegClass", ";", "}", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREXRegClass", ";", "return", "&", "X86", "::", "GR32_NOREXRegClass", ";", "case", "3", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREX_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "case", "4", ":", "return", "getGPRsForTailCall", "(", "MF", ")", ";", "}", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86", "X86::LOW32_ADDR_ACCESS_RBPRegClass", "X86::LOW32_ADDR_ACCESSRegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_NOREXRegClass", "X86::GR32_NOREXRegClass", "3", "X86::GR64_NOREX_NOSPRegClass", "X86::GR32_NOREX_NOSPRegClass", "4" ]

[]

[ "<s>", "SDValue", "OpenRISCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "tree", "bpf_handle_preserve_access_index_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "RECORD_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "UNION_TYPE", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to structure, union and class types\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "preserve_access_index", "attribute", ",", "which", "can", "be", "applied", "to", "structs", ",", "unions", "and", "classes", ".", "Actually", "adding", "the", "attribute", "to", "the", "TYPE_DECL", "is", "taken", "care", "of", "for", "us", ",", "so", "just", "warn", "for", "types", "that", "are", "n't", "supported", "." ]

[ "bpf", "\"%qE attribute only applies to structure, union and class types\"" ]

[]

[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "StringRef", "CPUName", "=", "MIPS_MC", "::", "selectMipsCPU", "(", "TM", ".", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "std", "::", "string", "CheriFeatures", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getEnvironment", "(", ")", "==", "llvm", "::", "Triple", "::", "CheriPurecap", ")", "{", "if", "(", "FS", ".", "empty", "(", ")", ")", "FS", "=", "\"+cheri128\"", ";", "else", "{", "CheriFeatures", "=", "FS", ".", "str", "(", ")", ";", "if", "(", "!", "FS", ".", "contains", "(", "\"+cheri256\"", ")", "&&", "!", "FS", ".", "contains", "(", "\"+cheri64\"", ")", ")", "CheriFeatures", "+=", "\",+cheri128\"", ";", "FS", "=", "CheriFeatures", ";", "}", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "IsSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "*", "StackAlignOverride", ";", "else", "if", "(", "isCheri", "(", ")", ")", "{", "if", "(", "isCheri256", "(", ")", ")", "stackAlignment", "=", "Align", "(", "32", ")", ";", "else", "stackAlignment", "=", "Align", "(", "16", ")", ";", "}", "else", "if", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "stackAlignment", "=", "Align", "(", "16", ")", ";", "else", "{", "assert", "(", "isABI_O32", "(", ")", "&&", "\"Unknown ABI for stack alignment!\"", ")", ";", "stackAlignment", "=", "Align", "(", "8", ")", ";", "}", "if", "(", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "&&", "!", "isGP64bit", "(", ")", ")", "report_fatal_error", "(", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "MIPS_MC::selectMipsCPU", "\"+cheri128\"", "\"+cheri256\"", "\"+cheri64\"", "\",+cheri128\"", "Mips", "Mips", "32", "16", "16", "\"Unknown ABI for stack alignment!\"", "8", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"" ]

[]

[ "<s>", "void", "get_ppc476_thunk_name", "(", "char", "name", "[", "32", "]", ")", "{", "gcc_assert", "(", "TARGET_LINK_STACK", ")", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "sprintf", "(", "name", ",", "\"__ppc476.get_thunk\"", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LPPC476_\"", ",", "0", ")", ";", "}", "</s>" ]

[ "Fills", "in", "the", "label", "name", "that", "should", "be", "used", "for", "a", "476", "link", "stack", "thunk", "." ]

[ "powerpcspe", "32", "\"__ppc476.get_thunk\"", "\"LPPC476_\"", "0" ]

[]

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "BBInfoVector", "&", "BBInfo", "=", "BBUtils", "->", "getBBInfo", "(", ")", ";", "assert", "(", "std", "::", "is_sorted", "(", "MF", "->", "begin", "(", ")", ",", "MF", "->", "end", "(", ")", ",", "[", "&", "BBInfo", "]", "(", "const", "MachineBasicBlock", "&", "LHS", ",", "const", "MachineBasicBlock", "&", "RHS", ")", "{", "return", "BBInfo", "[", "LHS", ".", "getNumber", "(", ")", "]", ".", "postOffset", "(", ")", "<", "BBInfo", "[", "RHS", ".", "getNumber", "(", ")", "]", ".", "postOffset", "(", ")", ";", "}", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Verifying \"", "<<", "CPUsers", ".", "size", "(", ")", "<<", "\" CP users.\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", "+", "2", ",", "U", ".", "NegOk", ",", "true", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"OK\\n\"", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Out of range.\\n\"", ")", ";", "dumpBBs", "(", ")", ";", "LLVM_DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "\"Verifying \"", "\" CP users.\\n\"", "0", "2", "\"OK\\n\"", "\"Out of range.\\n\"", "\"Constant pool entry out of range!\"" ]

[]

[ "<s>", "static", "rtx", "s390_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "named", ")", "s390_check_type_for_vector_abi", "(", "type", ",", "true", ",", "false", ")", ";", "if", "(", "s390_function_arg_vector", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "!", "named", "||", "(", "cum", "->", "vrs", "+", "1", ">", "VEC_ARG_NUM_REG", ")", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "vrs", "+", "FIRST_VEC_ARG_REGNO", ")", ";", "}", "else", "if", "(", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "cum", "->", "fprs", "+", "1", ">", "FP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fprs", "+", "16", ")", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "int", "n_gprs", "=", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ";", "if", "(", "cum", "->", "gprs", "+", "n_gprs", ">", "GP_ARG_NUM_REG", ")", "return", "NULL_RTX", ";", "else", "if", "(", "n_gprs", "==", "1", "||", "UNITS_PER_WORD", "==", "UNITS_PER_LONG", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "gprs", "+", "2", ")", ";", "else", "if", "(", "n_gprs", "==", "2", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "p", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "cum", "->", "gprs", "+", "2", ")", ",", "const0_rtx", ")", ";", "RTVEC_ELT", "(", "p", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "cum", "->", "gprs", "+", "3", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "p", ")", ";", "}", "}", "else", "if", "(", "type", "==", "void_type_node", ")", "return", "const0_rtx", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "S/390", ",", "we", "use", "general", "purpose", "registers", "2", "through", "6", "to", "pass", "integer", ",", "pointer", ",", "and", "certain", "structure", "arguments", ",", "and", "floating", "point", "registers", "0", "and", "2", "(", "0", ",", "2", ",", "4", ",", "and", "6", "on", "64-bit", ")", "to", "pass", "floating", "point", "arguments", ".", "All", "remaining", "arguments", "are", "pushed", "to", "the", "stack", "." ]

[ "s390", "1", "1", "16", "1", "1", "2", "2", "2", "0", "2", "1", "3", "4" ]

[]

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

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

[ "CAHP" ]

[]

[ "<s>", "MachineInstr", "*", "GBZ80InstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "case", "GBZ80", "::", "ADD8r", ":", "case", "GBZ80", "::", "ADD16r", ":", "case", "GBZ80", "::", "ADC8r", ":", "case", "GBZ80", "::", "ADC16r", ":", "case", "GBZ80", "::", "AND8r", ":", "case", "GBZ80", "::", "XOR8r", ":", "case", "GBZ80", "::", "OR8r", ":", "break", ";", "case", "GBZ80", "::", "ADD8i", ":", "case", "GBZ80", "::", "ADC8i", ":", "case", "GBZ80", "::", "AND8i", ":", "case", "GBZ80", "::", "XOR8i", ":", "case", "GBZ80", "::", "OR8i", ":", "return", "NULL", ";", "}", "assert", "(", "!", "NewMI", "&&", "\"Not implemented yet!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "reg", "[", "2", "]", ",", "arg", "[", "]", "=", "{", "0", ",", "0", "}", ";", "MachineInstr", "*", "MILoadReg", "=", "MI", "->", "getPrevNode", "(", ")", ";", "if", "(", "MILoadReg", "==", "NULL", "||", "MILoadReg", "->", "getOpcode", "(", ")", "!=", "GBZ80", "::", "COPY", ")", "return", "NULL", ";", "MachineOperand", "&", "MO0", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MO1", "=", "MILoadReg", "->", "getOperand", "(", "1", ")", ";", "reg", "[", "0", "]", "=", "MO0", ".", "getReg", "(", ")", ";", "reg", "[", "1", "]", "=", "MO1", ".", "getReg", "(", ")", ";", "unsigned", "PreferArg", "=", "-", "1", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "MFE", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "MFE", ";", "MFI", "++", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MFI", "->", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MFI", "->", "end", "(", ")", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "COPY", ")", "{", "if", "(", "MBBI", "->", "findRegisterDefOperand", "(", "reg", "[", "0", "]", ")", ")", "{", "arg", "[", "0", "]", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "arg", "[", "0", "]", ")", ")", "PreferArg", "=", "0", ";", "}", "if", "(", "MBBI", "->", "findRegisterDefOperand", "(", "reg", "[", "1", "]", ")", ")", "{", "arg", "[", "1", "]", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "arg", "[", "0", "]", ")", ")", "PreferArg", "=", "1", ";", "}", "if", "(", "arg", "[", "0", "]", "&&", "arg", "[", "1", "]", ")", "break", ";", "}", "MBBI", "++", ";", "}", "if", "(", "arg", "[", "0", "]", "&&", "arg", "[", "1", "]", ")", "break", ";", "}", "if", "(", "arg", "[", "0", "]", "==", "0", "||", "arg", "[", "1", "]", "==", "0", ")", "{", "return", "NULL", ";", "}", "if", "(", "PreferArg", "==", "0", ")", "{", "MO0", ".", "setReg", "(", "reg", "[", "1", "]", ")", ";", "MO1", ".", "setReg", "(", "reg", "[", "0", "]", ")", ";", "}", "else", "{", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GBZ80::ADD8r", "GBZ80::ADD16r", "GBZ80::ADC8r", "GBZ80::ADC16r", "GBZ80::AND8r", "GBZ80::XOR8r", "GBZ80::OR8r", "GBZ80::ADD8i", "GBZ80::ADC8i", "GBZ80::AND8i", "GBZ80::XOR8i", "GBZ80::OR8i", "\"Not implemented yet!\"", "2", "0", "0", "GBZ80::COPY", "0", "1", "0", "1", "1", "0", "0", "1", "0", "0", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<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.\"", ")", ";", "LLVM_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>", "static", "void", "ix86_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ")", "{", "ptr", "->", "arch", "=", "ix86_arch", ";", "ptr", "->", "schedule", "=", "ix86_schedule", ";", "ptr", "->", "prefetch_sse", "=", "x86_prefetch_sse", ";", "ptr", "->", "tune", "=", "ix86_tune", ";", "ptr", "->", "branch_cost", "=", "ix86_branch_cost", ";", "ptr", "->", "tune_defaulted", "=", "ix86_tune_defaulted", ";", "ptr", "->", "arch_specified", "=", "ix86_arch_specified", ";", "ptr", "->", "x_ix86_isa_flags_explicit", "=", "opts", "->", "x_ix86_isa_flags_explicit", ";", "ptr", "->", "x_ix86_target_flags_explicit", "=", "opts", "->", "x_ix86_target_flags_explicit", ";", "ptr", "->", "x_recip_mask_explicit", "=", "opts", "->", "x_recip_mask_explicit", ";", "ptr", "->", "x_ix86_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "ptr", "->", "x_ix86_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "ptr", "->", "x_ix86_cmodel", "=", "opts", "->", "x_ix86_cmodel", ";", "ptr", "->", "x_ix86_abi", "=", "opts", "->", "x_ix86_abi", ";", "ptr", "->", "x_ix86_asm_dialect", "=", "opts", "->", "x_ix86_asm_dialect", ";", "ptr", "->", "x_ix86_branch_cost", "=", "opts", "->", "x_ix86_branch_cost", ";", "ptr", "->", "x_ix86_dump_tunes", "=", "opts", "->", "x_ix86_dump_tunes", ";", "ptr", "->", "x_ix86_force_align_arg_pointer", "=", "opts", "->", "x_ix86_force_align_arg_pointer", ";", "ptr", "->", "x_ix86_force_drap", "=", "opts", "->", "x_ix86_force_drap", ";", "ptr", "->", "x_ix86_incoming_stack_boundary_arg", "=", "opts", "->", "x_ix86_incoming_stack_boundary_arg", ";", "ptr", "->", "x_ix86_pmode", "=", "opts", "->", "x_ix86_pmode", ";", "ptr", "->", "x_ix86_preferred_stack_boundary_arg", "=", "opts", "->", "x_ix86_preferred_stack_boundary_arg", ";", "ptr", "->", "x_ix86_recip_name", "=", "opts", "->", "x_ix86_recip_name", ";", "ptr", "->", "x_ix86_regparm", "=", "opts", "->", "x_ix86_regparm", ";", "ptr", "->", "x_ix86_section_threshold", "=", "opts", "->", "x_ix86_section_threshold", ";", "ptr", "->", "x_ix86_sse2avx", "=", "opts", "->", "x_ix86_sse2avx", ";", "ptr", "->", "x_ix86_stack_protector_guard", "=", "opts", "->", "x_ix86_stack_protector_guard", ";", "ptr", "->", "x_ix86_stringop_alg", "=", "opts", "->", "x_ix86_stringop_alg", ";", "ptr", "->", "x_ix86_tls_dialect", "=", "opts", "->", "x_ix86_tls_dialect", ";", "ptr", "->", "x_ix86_tune_ctrl_string", "=", "opts", "->", "x_ix86_tune_ctrl_string", ";", "ptr", "->", "x_ix86_tune_memcpy_strategy", "=", "opts", "->", "x_ix86_tune_memcpy_strategy", ";", "ptr", "->", "x_ix86_tune_memset_strategy", "=", "opts", "->", "x_ix86_tune_memset_strategy", ";", "ptr", "->", "x_ix86_tune_no_default", "=", "opts", "->", "x_ix86_tune_no_default", ";", "ptr", "->", "x_ix86_veclibabi_type", "=", "opts", "->", "x_ix86_veclibabi_type", ";", "gcc_assert", "(", "ptr", "->", "arch", "==", "ix86_arch", ")", ";", "gcc_assert", "(", "ptr", "->", "schedule", "==", "ix86_schedule", ")", ";", "gcc_assert", "(", "ptr", "->", "tune", "==", "ix86_tune", ")", ";", "gcc_assert", "(", "ptr", "->", "branch_cost", "==", "ix86_branch_cost", ")", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "i386" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "O", "<<", "'\\n'", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "8", ">", "(", "Imm", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "8" ]

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "MSP430", "MVT::i8" ]

[]

[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "bool", "IsSDWA", "=", "false", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureGCN3Encoding", "]", ")", "report_fatal_error", "(", "\"Disassembly not yet supported for subtarget\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableGFX964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "insertNamedMCOperand", "(", "MI", ",", "MCOperand", "::", "createImm", "(", "0", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "}", "if", "(", "Res", "&&", "IsSDWA", ")", "Res", "=", "convertSDWAInst", "(", "MI", ")", ";", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::FeatureGCN3Encoding", "\"Disassembly not yet supported for subtarget\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "AMDGPU::V_MAC_F32_e64_vi", "AMDGPU::V_MAC_F32_e64_si", "AMDGPU::V_MAC_F16_e64_vi", "0", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "static", "section", "*", "riscv_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "switch", "(", "categorize_decl_for_section", "(", "decl", ",", "reloc", ")", ")", "{", "case", "SECCAT_SRODATA", ":", "return", "get_named_section", "(", "decl", ",", "\".srodata\"", ",", "reloc", ")", ";", "default", ":", "return", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "}", "}", "</s>" ]

[ "Switch", "to", "the", "appropriate", "section", "for", "output", "of", "DECL", "." ]

[ "riscv", "\".srodata\"" ]

[]

[ "<s>", "void", "RISCVAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "RISCVTargetStreamer", "&", "RTS", "=", "static_cast", "<", "RISCVTargetStreamer", "&", ">", "(", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "RTS", ".", "finishAttributeSection", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "int", "standard_80387_constant_p", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "const", "REAL_VALUE_TYPE", "*", "r", ";", "if", "(", "!", "(", "CONST_DOUBLE_P", "(", "x", ")", "&&", "X87_FLOAT_MODE_P", "(", "mode", ")", ")", ")", "return", "-", "1", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "1", ";", "if", "(", "x", "==", "CONST1_RTX", "(", "mode", ")", ")", "return", "2", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "mode", "==", "XFmode", "&&", "(", "optimize_function_for_size_p", "(", "cfun", ")", "||", "TARGET_EXT_80387_CONSTANTS", ")", "&&", "!", "flag_rounding_math", ")", "{", "int", "i", ";", "if", "(", "!", "ext_80387_constants_init", ")", "init_ext_80387_constants", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "if", "(", "real_identical", "(", "r", ",", "&", "ext_80387_constants_table", "[", "i", "]", ")", ")", "return", "i", "+", "3", ";", "}", "if", "(", "real_isnegzero", "(", "r", ")", ")", "return", "8", ";", "if", "(", "real_identical", "(", "r", ",", "&", "dconstm1", ")", ")", "return", "9", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "constant", "is", "something", "that", "can", "be", "loaded", "with", "a", "special", "instruction", "." ]

[ "i386", "1", "1", "2", "0", "5", "3", "8", "9", "0" ]

[]

[ "<s>", "bool", "PatmosIntrinsicElimination", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "for", "(", "auto", "BB_iter", "=", "F", ".", "begin", "(", ")", ",", "BB_iter_end", "=", "F", ".", "end", "(", ")", ";", "BB_iter", "!=", "BB_iter_end", ";", "++", "BB_iter", ")", "{", "if", "(", "eliminateIntrinsic", "(", "F", ",", "*", "BB_iter", ")", ")", "{", "BB_iter", "=", "F", ".", "begin", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"AArch64TargetLowering::getAddr\\n\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Hi", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_PAGE", ")", ";", "SDValue", "Lo", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_PAGEOFF", "|", "AArch64II", "::", "MO_NC", ")", ";", "SDValue", "ADRP", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "ADRP", ",", "DL", ",", "Ty", ",", "Hi", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "ADDlow", ",", "DL", ",", "Ty", ",", "ADRP", ",", "Lo", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"AArch64TargetLowering::getAddr\\n\"", "AArch64II::MO_PAGE", "AArch64II::MO_PAGEOFF", "AArch64II::MO_NC", "AArch64ISD::ADRP", "AArch64ISD::ADDlow" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "MSP430" ]

[]

[ "<s>", "unsigned", "getMaxCallFrameSize", "(", ")", "const", "{", "return", "MaxCallFrameSize", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "size", "of", "a", "call", "frame", "that", "must", "be", "allocated", "for", "an", "outgoing", "function", "call", "." ]

[ "rvex" ]

[]

[ "<s>", "static", "void", "alpha_add_builtins", "(", "const", "struct", "alpha_builtin_def", "*", "p", ",", "size_t", "count", ",", "tree", "ftype", ")", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "++", "i", ",", "++", "p", ")", "if", "(", "(", "target_flags", "&", "p", "->", "target_mask", ")", "==", "p", "->", "target_mask", ")", "alpha_builtin_function", "(", "p", "->", "name", ",", "ftype", ",", "p", "->", "code", ",", "(", "p", "->", "is_const", "?", "ECF_CONST", ":", "0", ")", "|", "ECF_NOTHROW", ")", ";", "}", "</s>" ]

[ "Helper", "function", "of", "alpha_init_builtins", ".", "Add", "the", "COUNT", "built-in", "functions", "pointed", "to", "by", "P", ",", "with", "function", "type", "FTYPE", "." ]

[ "alpha", "0", "0" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "ARMTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "bool", "HasAtomicCmpXchg", "=", "!", "Subtarget", "->", "isThumb", "(", ")", "||", "Subtarget", "->", "hasV8MBaselineOps", "(", ")", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "0", "&&", "HasAtomicCmpXchg", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "return", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

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

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

[ "MINA32", "MINA32" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "arm_init_vfp_builtins", "(", "void", ")", "{", "unsigned", "int", "i", ",", "fcode", "=", "ARM_BUILTIN_VFP_PATTERN_START", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "vfp_builtin_data", ")", ";", "i", "++", ",", "fcode", "++", ")", "{", "arm_builtin_datum", "*", "d", "=", "&", "vfp_builtin_data", "[", "i", "]", ";", "arm_init_builtin", "(", "fcode", ",", "d", ",", "\"__builtin_neon\"", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "all", "the", "scalar", "floating", "point", "builtins", "." ]

[ "arm", "0", "\"__builtin_neon\"" ]

[]

[ "<s>", "static", "void", "c6x_initialize_trampoline", "(", "rtx", "tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "t1", "=", "copy_to_reg", "(", "fnaddr", ")", ";", "rtx", "t2", "=", "copy_to_reg", "(", "cxt", ")", ";", "rtx", "mask", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "int", "i", ";", "emit_block_move", "(", "tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "emit_move_insn", "(", "mask", ",", "GEN_INT", "(", "0xffff", "<<", "7", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "rtx", "mem", "=", "adjust_address", "(", "tramp", ",", "SImode", ",", "i", "*", "4", ")", ";", "rtx", "t", "=", "(", "i", "&", "1", ")", "?", "t2", ":", "t1", ";", "rtx", "v1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "v2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "v1", ",", "mem", ")", ";", "if", "(", "i", "<", "2", ")", "emit_insn", "(", "gen_ashlsi3", "(", "v2", ",", "t", ",", "GEN_INT", "(", "7", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_lshrsi3", "(", "v2", ",", "t", ",", "GEN_INT", "(", "9", ")", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "v2", ",", "v2", ",", "mask", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "v2", ",", "v2", ",", "v1", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "v2", ")", ";", "}", "tramp", "=", "XEXP", "(", "tramp", ",", "0", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__gnu_clear_cache\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "2", ",", "tramp", ",", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "TRAMPOLINE_SIZE", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "TRAMP", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "c6x", "0", "0xffff", "7", "0", "4", "4", "1", "2", "7", "9", "0", "\"__gnu_clear_cache\"", "2" ]

[]

[ "<s>", "void", "RISCVAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "return", ";", "}", "</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", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ")", ";", "TLSDataSection", "=", "DataSection", ";", "TLSBSSSection", "=", "BSSSection", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "DataRelSection", "=", "DataRelLocalSection", "=", "DataSection", ";", "DataRelROSection", "=", "DataRelROLocalSection", "=", "ReadOnlySection", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.data\"", "\".dp.bss\"", "\".cp.rodata.cst4\"", "\".cp.rodata.cst8\"", "\".cp.rodata.cst16\"", "\".cp.rodata\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "RISCVTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "RISCVPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "RI5CY", "RISCV", "RISCV" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "Small", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "RISCVTargetLowering", "::", "ConstraintType", "RISCVTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "return", "C_Immediate", ";", "case", "'A'", ":", "return", "C_Memory", ";", "case", "'S'", ":", "return", "C_Other", ";", "}", "}", "else", "{", "if", "(", "Constraint", "==", "\"vr\"", "||", "Constraint", "==", "\"vm\"", ")", "return", "C_RegisterClass", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "1", "0", "\"vr\"", "\"vm\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "PPCScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfoImpl", "::", "CreateTargetHazardRecognizer", "(", "TM", ",", "DAG", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "arm_add_stmt_cost", "(", "vec_info", "*", "vinfo", ",", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "tree", "vectype", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "unsigned", "*", "cost", "=", "(", "unsigned", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "int", "stmt_cost", "=", "arm_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "vinfo", ",", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

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

[ "arm", "0", "50" ]

[]

[ "<s>", "SDValue", "KudeyarTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "Kudeyar_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Kudeyar", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "Kudeyar_INTR", "?", "KudeyarISD", "::", "RETI_FLAG", ":", "KudeyarISD", "::", "RET_FLAG", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "ISD::OutputArg", "16", "Kudeyar", "\"ISRs cannot return any value\"", "Kudeyar", "0", "0", "\"Can only return in registers!\"", "1", "Kudeyar", "KudeyarISD::RETI_FLAG", "KudeyarISD::RET_FLAG", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "void", "validate_condition_mode", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "(", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_COMPARE", "||", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_COMM_COMPARE", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", ";", "gcc_assert", "(", "(", "code", "!=", "GT", "&&", "code", "!=", "LT", "&&", "code", "!=", "GE", "&&", "code", "!=", "LE", ")", "||", "mode", "!=", "CCUNSmode", ")", ";", "gcc_assert", "(", "(", "code", "!=", "GTU", "&&", "code", "!=", "LTU", "&&", "code", "!=", "GEU", "&&", "code", "!=", "LEU", ")", "||", "mode", "==", "CCUNSmode", ")", ";", "gcc_assert", "(", "mode", "==", "CCFPmode", "||", "(", "code", "!=", "ORDERED", "&&", "code", "!=", "UNORDERED", "&&", "code", "!=", "UNEQ", "&&", "code", "!=", "LTGT", "&&", "code", "!=", "UNGT", "&&", "code", "!=", "UNLT", "&&", "code", "!=", "UNGE", "&&", "code", "!=", "UNLE", ")", ")", ";", "gcc_assert", "(", "mode", "!=", "CCFPmode", "||", "flag_finite_math_only", "||", "(", "code", "!=", "LE", "&&", "code", "!=", "GE", "&&", "code", "!=", "UNEQ", "&&", "code", "!=", "LTGT", "&&", "code", "!=", "UNGT", "&&", "code", "!=", "UNLT", ")", ")", ";", "gcc_assert", "(", "mode", "!=", "CCEQmode", "||", "code", "==", "EQ", "||", "code", "==", "NE", ")", ";", "}", "</s>" ]

[ "A", "validation", "routine", ":", "say", "whether", "CODE", ",", "a", "condition", "code", ",", "and", "MODE", "match", ".", "The", "other", "alternatives", "either", "do", "n't", "make", "sense", "or", "should", "never", "be", "generated", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "mips_reversed_fp_cond", "(", "enum", "rtx_code", "*", "code", ")", "{", "switch", "(", "*", "code", ")", "{", "case", "NE", ":", "case", "LTGT", ":", "case", "ORDERED", ":", "*", "code", "=", "reverse_condition_maybe_unordered", "(", "*", "code", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Convert", "*", "CODE", "into", "a", "code", "that", "can", "be", "used", "in", "a", "floating-point", "scc", "instruction", "(", "C.cond.fmt", ")", ".", "Return", "true", "if", "the", "values", "of", "the", "condition", "code", "registers", "will", "be", "inverted", ",", "with", "0", "indicating", "that", "the", "condition", "holds", "." ]

[ "mips" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "int", "MCOpcode", "=", "ST", ".", "getInstrInfo", "(", ")", "->", "pseudoToMCOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "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", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "GV", "->", "getName", "(", ")", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_TargetIndex", ":", "{", "assert", "(", "MO", ".", "getIndex", "(", ")", "==", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "END_OF_TEXT_LABEL_NAME", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "break", ";", "}", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "\"unknown operand type\"", "AMDGPU::TI_CONSTDATA_START" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", ")", "return", "Match_InvalidOperand", ";", "return", "Match_Success", ";", "}", "</s>" ]

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

[ "R600", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AAPRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

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

[ "AAP", "AAP" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "HasFPUDelaySlot", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "MTC1", ":", "case", "Mips", "::", "MFC1", ":", "case", "Mips", "::", "MTC1_D64", ":", "case", "Mips", "::", "MFC1_D64", ":", "case", "Mips", "::", "DMTC1", ":", "case", "Mips", "::", "DMFC1", ":", "case", "Mips", "::", "FCMP_S32", ":", "case", "Mips", "::", "FCMP_D32", ":", "case", "Mips", "::", "FCMP_D64", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Predicate", "to", "determine", "if", "an", "instruction", "has", "an", "FPU", "delay", "slot", "." ]

[ "Mips", "Mips", "Mips::MTC1", "Mips::MFC1", "Mips::MTC1_D64", "Mips::MFC1_D64", "Mips::DMTC1", "Mips::DMFC1", "Mips::FCMP_S32", "Mips::FCMP_D32", "Mips::FCMP_D64" ]

[]

[ "<s>", "const", "MCExpr", "*", "MipsTargetObjectFile", "::", "getDebugThreadLocalSymbol", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "getContext", "(", ")", ")", ";", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "0x8000", ",", "getContext", "(", ")", ")", ",", "getContext", "(", ")", ")", ";", "return", "MipsMCExpr", "::", "create", "(", "MipsMCExpr", "::", "MEK_DTPREL", ",", "Expr", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Describe", "a", "TLS", "variable", "address", "within", "debug", "info", "." ]

[ "Mips", "Mips", "0x8000", "Mips", "Mips" ]

[]

[ "<s>", "const", "RegisterBank", "&", "MipsRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "Mips", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirstRegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", ":", "case", "Mips", "::", "SP32RegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::GPR32RegClassID", "Mips::CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirstRegClassID", "Mips::CPU16Regs_and_GPRMM16MovePPairSecondRegClassID", "Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID", "Mips::SP32RegClassID", "Mips::GPRBRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isSimpleMove", "(", "MI", ",", "FrameIndex", ",", "SystemZII", "::", "SimpleBDXLoad", ")", ";", "}", "</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", "." ]

[ "SystemZ", "SystemZ", "SystemZII::SimpleBDXLoad" ]

[]

[ "<s>", "bool", "MSP430TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createMSP430ISelDag", "(", "*", "this", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "MCS51AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "ExpectedKind", ")", "{", "MCS51Operand", "&", "Op", "=", "static_cast", "<", "MCS51Operand", "&", ">", "(", "AsmOp", ")", ";", "MatchClassKind", "Expected", "=", "static_cast", "<", "MatchClassKind", ">", "(", "ExpectedKind", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "MCConstantExpr", "const", "*", "Const", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "{", "int64_t", "RegNum", "=", "Const", "->", "getValue", "(", ")", ";", "std", "::", "ostringstream", "RegName", ";", "RegName", "<<", "\"r\"", "<<", "RegNum", ";", "RegNum", "=", "MatchRegisterName", "(", "RegName", ".", "str", "(", ")", ".", "c_str", "(", ")", ")", ";", "if", "(", "RegNum", "!=", "MCS51", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "RegNum", ")", ";", "if", "(", "validateOperandClass", "(", "Op", ",", "Expected", ")", "==", "Match_Success", ")", "{", "return", "Match_Success", ";", "}", "}", "}", "}", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "isSubclass", "(", "Expected", ",", "MCK_DREGS", ")", ")", "{", "unsigned", "correspondingDREG", "=", "toDREG", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "correspondingDREG", "!=", "MCS51", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "correspondingDREG", ")", ";", "return", "validateOperandClass", "(", "Op", ",", "Expected", ")", ";", "}", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "\"r\"", "MCS51::NoRegister", "MCS51::NoRegister" ]

[]

[ "<s>", "static", "int", "find_unused_clobbered_reg", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "if", "(", "!", "regs_ever_live", "[", "i", "]", ")", "return", "i", ";", "return", "0", ";", "}", "</s>" ]

[ "Find", "first", "call", "clobbered", "register", "unsused", "in", "a", "function", ".", "This", "could", "be", "used", "as", "base", "register", "in", "a", "leaf", "function", "or", "for", "holding", "the", "return", "address", "before", "epilogue", "." ]

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

[]

[ "<s>", "static", "void", "s390_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_USER_ALIGN", "(", "decl", ")", "&&", "DECL_ALIGN", "(", "decl", ")", "<", "16", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_ALIGN1", ";", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "(", "local", "vs.", "global", ",", "tls", "model", ")", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

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

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "R600", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "R600", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "R600", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "R600", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "R600", "::", "MOVA_INT_eg", ",", "R600", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "*", "MOVA", ",", "R600", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "R600", "::", "MOV", ",", "ValueReg", ",", "AddrReg", ")", ".", "addReg", "(", "R600", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "*", "Mov", ",", "R600", "::", "OpName", "::", "src0_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "R600::R600_AddrRegClass", "1", "R600::R600_Addr_YRegClass", "2", "R600::R600_Addr_ZRegClass", "3", "R600::R600_Addr_WRegClass", "R600::MOVA_INT_eg", "R600::AR_X", "R600::OpName", "0", "R600::MOV", "R600::AR_X", "R600::OpName", "1" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "forceScalarizeMaskedGather", "(", "VectorType", "*", "VTy", ",", "Align", "Alignment", ")", "{", "unsigned", "NumElts", "=", "cast", "<", "FixedVectorType", ">", "(", "VTy", ")", "->", "getNumElements", "(", ")", ";", "return", "NumElts", "==", "1", "||", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "NumElts", "==", "2", "||", "(", "NumElts", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "forces", "scalarizing", "of", "llvm.masked.gather", "intrinsics", "." ]

[ "X86", "X86", "1", "2", "4" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "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", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128-ni:1\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128-ni:1\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ",", "TT", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Large", ")", ",", "OL", ")", ",", "TLOF", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "WebAssembly", "architecture", "model", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128-ni:1\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128-ni:1\"", "WebAssembly" ]

[]

[ "<s>", "uint32_t", "AArch64MCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"Unexpected ADR target type!\"", ")", ";", "MCFixupKind", "Kind", "=", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "BL", "?", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_pcrel_call26", ")", ":", "MCFixupKind", "(", "AArch64", "::", "fixup_aarch64_pcrel_branch26", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "AArch64", "AArch64", "\"Unexpected ADR target type!\"", "AArch64::BL", "AArch64::fixup_aarch64_pcrel_call26", "AArch64::fixup_aarch64_pcrel_branch26", "0", "0" ]

[]

[ "<s>", "bool", "arm_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_NEON", "&&", "(", "mode", "==", "V2SFmode", "||", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V4HFmode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V2DImode", "||", "mode", "==", "V8HFmode", "||", "mode", "==", "V4BFmode", "||", "mode", "==", "V8BFmode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_NEON", "||", "TARGET_IWMMXT", ")", "&&", "(", "(", "mode", "==", "V2SImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V8QImode", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_INT_SIMD", "&&", "(", "mode", "==", "V4UQQmode", "||", "mode", "==", "V4QQmode", "||", "mode", "==", "V2UHQmode", "||", "mode", "==", "V2HQmode", "||", "mode", "==", "V2UHAmode", "||", "mode", "==", "V2HAmode", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE", "&&", "(", "VALID_MVE_SI_MODE", "(", "mode", ")", "||", "VALID_MVE_PRED_MODE", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE_FLOAT", "&&", "(", "mode", "==", "V2DFmode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V8HFmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "arm" ]

[]

[ "<s>", "const", "RISCVSubtarget", "*", "RISCVTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "CPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "std", "::", "string", "Key", "=", "CPU", "+", "TuneCPU", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "auto", "ABIName", "=", "Options", ".", "MCOptions", ".", "getABIName", "(", ")", ";", "if", "(", "const", "MDString", "*", "ModuleTargetABI", "=", "dyn_cast_or_null", "<", "MDString", ">", "(", "F", ".", "getParent", "(", ")", "->", "getModuleFlag", "(", "\"target-abi\"", ")", ")", ")", "{", "auto", "TargetABI", "=", "RISCVABI", "::", "getTargetABI", "(", "ABIName", ")", ";", "if", "(", "TargetABI", "!=", "RISCVABI", "::", "ABI_Unknown", "&&", "ModuleTargetABI", "->", "getString", "(", ")", "!=", "ABIName", ")", "{", "report_fatal_error", "(", "\"-target-abi option != target-abi module flag\"", ")", ";", "}", "ABIName", "=", "ModuleTargetABI", "->", "getString", "(", ")", ";", "}", "I", "=", "std", "::", "make_unique", "<", "RISCVSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "ABIName", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "\"target-abi\"", "RISCVABI::getTargetABI", "RISCVABI::ABI_Unknown", "\"-target-abi option != target-abi module flag\"", "RISCV" ]

[]

[ "<s>", "void", "Thumb2RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "t2LDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "(", "int64_t", ")", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::t2LDRpci", "ARMCC::AL", "0" ]

[]

[ "<s>", "static", "bool", "vr4130_swap_insns_p", "(", "rtx_insn", "*", "insn1", ",", "rtx_insn", "*", "insn2", ")", "{", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "FOR_EACH_DEP", "(", "insn1", ",", "SD_LIST_FORW", ",", "sd_it", ",", "dep", ")", "if", "(", "DEP_TYPE", "(", "dep", ")", "==", "REG_DEP_ANTI", "&&", "INSN_PRIORITY", "(", "DEP_CON", "(", "dep", ")", ")", ">", "INSN_PRIORITY", "(", "insn2", ")", "&&", "recog_memoized", "(", "DEP_CON", "(", "dep", ")", ")", ">=", "0", "&&", "get_attr_vr4130_class", "(", "DEP_CON", "(", "dep", ")", ")", "==", "VR4130_CLASS_ALU", ")", "return", "false", ";", "if", "(", "vr4130_last_insn", "!=", "0", "&&", "recog_memoized", "(", "insn1", ")", ">=", "0", "&&", "recog_memoized", "(", "insn2", ")", ">=", "0", ")", "{", "enum", "attr_vr4130_class", "class1", "=", "get_attr_vr4130_class", "(", "insn1", ")", ";", "enum", "attr_vr4130_class", "class2", "=", "get_attr_vr4130_class", "(", "insn2", ")", ";", "if", "(", "class1", "!=", "class2", "||", "class1", "==", "VR4130_CLASS_ALU", ")", "{", "bool", "dep1_p", "=", "vr4130_true_reg_dependence_p", "(", "insn1", ")", ";", "bool", "dep2_p", "=", "vr4130_true_reg_dependence_p", "(", "insn2", ")", ";", "if", "(", "dep1_p", "!=", "dep2_p", ")", "return", "dep1_p", ";", "if", "(", "class1", "!=", "VR4130_CLASS_ALU", "&&", "recog_memoized", "(", "vr4130_last_insn", ")", ">=", "0", "&&", "class1", "==", "get_attr_vr4130_class", "(", "vr4130_last_insn", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "A", "TUNE_MIPS4130", "helper", "function", ".", "Given", "that", "INSN1", "is", "at", "the", "head", "of", "the", "ready", "queue", "and", "that", "INSN2", "is", "the", "instruction", "after", "it", ",", "return", "true", "if", "it", "is", "worth", "promoting", "INSN2", "ahead", "of", "INSN1", ".", "Look", "for", "cases", "in", "which", "INSN1", "and", "INSN2", "can", "probably", "issue", "in", "parallel", ",", "but", "for", "which", "(", "INSN2", ",", "INSN1", ")", "should", "be", "less", "sensitive", "to", "instruction", "alignment", "than", "(", "INSN1", ",", "INSN2", ")", ".", "See", "4130.md", "for", "more", "details", "." ]

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

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "void", "rl78_calculate_death_notes", "(", "void", ")", "{", "char", "dead", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "rtx", "insn", ",", "p", ",", "s", ",", "d", ";", "int", "i", ";", "memset", "(", "dead", ",", "0", ",", "sizeof", "(", "dead", ")", ")", ";", "for", "(", "insn", "=", "get_last_insn", "(", ")", ";", "insn", ";", "insn", "=", "prev_nonnote_nondebug_insn", "(", "insn", ")", ")", "{", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"\\n--------------------------------------------------\"", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\nDead:\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "dead", "[", "i", "]", ")", "fprintf", "(", "dump_file", ",", "\" %s\"", ",", "reg_names", "[", "i", "]", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "print_rtl_single", "(", "dump_file", ",", "insn", ")", ";", "}", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "INSN", ":", "p", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "p", ")", "==", "PARALLEL", ")", "{", "rtx", "q", "=", "XVECEXP", "(", "p", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "q", ")", "==", "SET", ")", "{", "s", "=", "SET_SRC", "(", "q", ")", ";", "d", "=", "SET_DEST", "(", "q", ")", ";", "rl78_note_reg_set", "(", "dead", ",", "d", ",", "insn", ")", ";", "rl78_note_reg_uses", "(", "dead", ",", "s", ",", "insn", ")", ";", "}", "p", "=", "XVECEXP", "(", "p", ",", "0", ",", "0", ")", ";", "}", "switch", "(", "GET_CODE", "(", "p", ")", ")", "{", "case", "SET", ":", "s", "=", "SET_SRC", "(", "p", ")", ";", "d", "=", "SET_DEST", "(", "p", ")", ";", "rl78_note_reg_set", "(", "dead", ",", "d", ",", "insn", ")", ";", "rl78_note_reg_uses", "(", "dead", ",", "s", ",", "insn", ")", ";", "break", ";", "case", "USE", ":", "rl78_note_reg_uses", "(", "dead", ",", "p", ",", "insn", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "case", "JUMP_INSN", ":", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_rl78_return", ")", "{", "memset", "(", "dead", ",", "1", ",", "sizeof", "(", "dead", ")", ")", ";", "break", ";", "}", "case", "CALL_INSN", ":", "memset", "(", "dead", ",", "0", ",", "sizeof", "(", "dead", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "dump_file", ")", "print_rtl_single", "(", "dump_file", ",", "insn", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "a", "rather", "crude", "register", "death", "pass", ".", "Death", "status", "is", "reset", "at", "every", "jump", "or", "call", "insn", "." ]

[ "rl78", "0", "\"\\n--------------------------------------------------\"", "\"\\nDead:\"", "0", "\" %s\"", "\"\\n\"", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "cris_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "smul_optab", ",", "SImode", ",", "\"__Mul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "SImode", ",", "\"__Div\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "SImode", ",", "\"__Udiv\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "SImode", ",", "\"__Mod\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "SImode", ",", "\"__Umod\"", ")", ";", "}", "</s>" ]

[ "Rename", "the", "function", "calls", "for", "integer", "multiply", "and", "divide", "." ]

[ "cris", "\"__Mul\"", "\"__Div\"", "\"__Udiv\"", "\"__Mod\"", "\"__Umod\"" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "new", "ScheduleDAGMI", "(", "C", ",", "make_unique", "<", "SystemZPostRASchedStrategy", ">", "(", "C", ")", ",", "true", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getArgRegsSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "if", "(", "STI", ".", "hasV4TOps", "(", ")", "&&", "!", "STI", ".", "hasV5TOps", "(", ")", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MIB", ".", "copyImplicitOps", "(", "&", "*", "MI", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "PIC16TargetObjectFile", "&", "getObjFileLowering", "(", ")", "const", "{", "return", "(", "PIC16TargetObjectFile", "&", ")", "AsmPrinter", "::", "getObjFileLowering", "(", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasPreallocatedCall", "(", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "XOR32rr", ")", ")", ";", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0B", ":", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::MOV32r0", "X86::XOR32rr", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::AVX512_512_SET0", "X86::VPXORDZrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri", "X86::KSET0B", "X86::KSET0W", "X86::KXORWrr", "X86::KSET1B", "X86::KSET1W", "X86::KXNORWrr" ]

[]

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

[ "CAHP" ]

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "PIC16TargetLowering", "*", "PTLI", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movf", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "1", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "{", "unsigned", "opcode", "=", "(", "DestReg", "==", "PIC16", "::", "FSR0", ")", "?", "PIC16", "::", "restore_fsr0", ":", "PIC16", "::", "restore_fsr1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "3", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16", "PIC16::GPRRegisterClass", "PIC16::movf", "1", "1", "PIC16::FSR16RegisterClass", "PIC16::FSR0", "PIC16::restore_fsr0", "PIC16::restore_fsr1", "3", "1", "\"Can't load this register from stack slot\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "TM", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "empty", "(", ")", "&&", "I", "->", "back", "(", ")", ".", "isReturn", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "WidenVector", "(", "SelectionDAG", "&", "DAG", ")", ":", "DAG", "(", "DAG", ")", "{", "}", "</s>" ]

[ "Widen", "the", "vector", "up", "to", "the", "next", "power", "of", "two", "using", "INSERT_SUBVECTOR", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "s390_bb_fallthru_entry_likely", "(", "basic_block", "bb", ")", "{", "edge", "e", ",", "fallthru_edge", ";", "edge_iterator", "ei", ";", "if", "(", "!", "bb", ")", "return", "false", ";", "fallthru_edge", "=", "find_fallthru_edge", "(", "bb", "->", "preds", ")", ";", "if", "(", "!", "fallthru_edge", ")", "return", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "e", "!=", "fallthru_edge", "&&", "e", "->", "probability", ">=", "profile_probability", "::", "unlikely", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "BB", "is", "entered", "via", "a", "fallthru", "edge", "and", "all", "other", "incoming", "edges", "are", "less", "than", "unlikely", "." ]

[ "s390" ]

[]

[ "<s>", "void", "sparc_emit_floatunsdi", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "i0", ",", "i1", ",", "f0", ",", "in", ",", "out", ";", "out", "=", "operands", "[", "0", "]", ";", "in", "=", "force_reg", "(", "DImode", ",", "operands", "[", "1", "]", ")", ";", "rtx_code_label", "*", "neglab", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "donelab", "=", "gen_label_rtx", "(", ")", ";", "i0", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "i1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "f0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_cmp_and_jump_insns", "(", "in", ",", "const0_rtx", ",", "LT", ",", "const0_rtx", ",", "DImode", ",", "0", ",", "neglab", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "out", ",", "gen_rtx_FLOAT", "(", "mode", ",", "in", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "donelab", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "neglab", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "i0", ",", "in", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_anddi3", "(", "i1", ",", "in", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_iordi3", "(", "i0", ",", "i0", ",", "i1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "f0", ",", "gen_rtx_FLOAT", "(", "mode", ",", "i0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "out", ",", "gen_rtx_PLUS", "(", "mode", ",", "f0", ",", "f0", ")", ")", ")", ";", "emit_label", "(", "donelab", ")", ";", "}", "</s>" ]

[ "Generate", "an", "unsigned", "DImode", "to", "FP", "conversion", ".", "This", "is", "the", "same", "code", "optabs", "would", "emit", "if", "we", "did", "n't", "have", "TFmode", "patterns", "." ]

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

[]

[ "<s>", "static", "bool", "zero_all_st_registers", "(", "HARD_REG_SET", "need_zeroed_hardregs", ")", "{", "if", "(", "!", "(", "TARGET_80387", "||", "TARGET_FLOAT_RETURNS_IN_80387", ")", ")", "return", "false", ";", "unsigned", "int", "num_of_st", "=", "0", ";", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "(", "STACK_REGNO_P", "(", "regno", ")", "||", "MMX_REGNO_P", "(", "regno", ")", ")", "&&", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "{", "num_of_st", "++", ";", "break", ";", "}", "if", "(", "num_of_st", "==", "0", ")", "return", "false", ";", "bool", "return_with_x87", "=", "false", ";", "return_with_x87", "=", "(", "crtl", "->", "return_rtx", "&&", "(", "STACK_REG_P", "(", "crtl", "->", "return_rtx", ")", ")", ")", ";", "bool", "complex_return", "=", "false", ";", "complex_return", "=", "(", "crtl", "->", "return_rtx", "&&", "COMPLEX_MODE_P", "(", "GET_MODE", "(", "crtl", "->", "return_rtx", ")", ")", ")", ";", "if", "(", "return_with_x87", ")", "if", "(", "complex_return", ")", "num_of_st", "=", "6", ";", "else", "num_of_st", "=", "7", ";", "else", "num_of_st", "=", "8", ";", "rtx", "st_reg", "=", "gen_rtx_REG", "(", "XFmode", ",", "FIRST_STACK_REG", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_of_st", ";", "i", "++", ")", "emit_insn", "(", "gen_rtx_SET", "(", "st_reg", ",", "CONST0_RTX", "(", "XFmode", ")", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "num_of_st", ";", "i", "++", ")", "{", "rtx", "insn", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "st_reg", ",", "st_reg", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_DEAD", ",", "st_reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Generate", "insns", "to", "zero", "all", "st", "registers", "together", ".", "Return", "true", "when", "zeroing", "instructions", "are", "generated", ".", "Assume", "the", "number", "of", "st", "registers", "that", "are", "zeroed", "is", "num_of_st", ",", "we", "will", "emit", "the", "following", "sequence", "to", "zero", "them", "together", ":", "fldz", ";", "\\", "fldz", ";", "\\", "...", "fldz", ";", "\\", "fstp", "%", "%", "st", "(", "0", ")", ";", "\\", "fstp", "%", "%", "st", "(", "0", ")", ";", "\\", "...", "fstp", "%", "%", "st", "(", "0", ")", ";", "i.e.", ",", "num_of_st", "fldz", "followed", "by", "num_of_st", "fstp", "to", "clear", "the", "stack", "mark", "stack", "slots", "empty", ".", "How", "to", "compute", "the", "num_of_st", ":", "There", "is", "no", "direct", "mapping", "from", "stack", "registers", "to", "hard", "register", "numbers", ".", "If", "one", "stack", "register", "needs", "to", "be", "cleared", ",", "we", "do", "n't", "know", "where", "in", "the", "stack", "the", "value", "remains", ".", "So", ",", "if", "any", "stack", "register", "needs", "to", "be", "cleared", ",", "the", "whole", "stack", "should", "be", "cleared", ".", "However", ",", "x87", "stack", "registers", "that", "hold", "the", "return", "value", "should", "be", "excluded", ".", "x87", "returns", "in", "the", "top", "(", "two", "for", "complex", "values", ")", "register", ",", "so", "num_of_st", "should", "be", "7/6", "when", "x87", "returns", ",", "otherwise", "it", "will", "be", "8", "." ]

[ "i386", "0", "0", "0", "6", "7", "8", "0", "0" ]

[]

[ "<s>", "rtx", "mve_bool_vec_to_const", "(", "rtx", "const_vec", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "const_vec", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "const_vec", ";", "unsigned", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "unsigned", "el_prec", "=", "GET_MODE_PRECISION", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "unsigned", "shift_c", "=", "16", "/", "n_elts", ";", "unsigned", "i", ";", "int", "hi_val", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "el", "=", "CONST_VECTOR_ELT", "(", "const_vec", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "elpart", ";", "gcc_assert", "(", "CONST_INT_P", "(", "el", ")", ")", ";", "elpart", "=", "INTVAL", "(", "el", ")", "&", "(", "(", "1U", "<<", "el_prec", ")", "-", "1", ")", ";", "unsigned", "index", "=", "BYTES_BIG_ENDIAN", "?", "n_elts", "-", "i", "-", "1", ":", "i", ";", "hi_val", "|=", "elpart", "<<", "(", "index", "*", "shift_c", ")", ";", "}", "return", "gen_int_mode", "(", "hi_val", ",", "SImode", ")", ";", "}", "</s>" ]

[ "Return", "a", "HI", "representation", "of", "CONST_VEC", "suitable", "for", "MVE", "predicates", "." ]

[ "arm", "16", "0", "0", "1U", "1", "1" ]

[]

[ "<s>", "static", "tree", "winnt_d_handle_target_object_format", "(", "void", ")", "{", "const", "char", "*", "objfmt", "=", "\"coff\"", ";", "return", "build_string_literal", "(", "strlen", "(", "objfmt", ")", "+", "1", ",", "objfmt", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "objectFormat", "''", ")", "'", "." ]

[ "i386", "\"coff\"", "1" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "MaybeAlign", "StackAlignOverride", ",", "unsigned", "PreferVectorWidthOverride", ",", "unsigned", "RequiredVectorWidth", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "PICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "PreferVectorWidthOverride", "(", "PreferVectorWidthOverride", ")", ",", "RequiredVectorWidth", "(", "RequiredVectorWidth", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "GOT", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "LiveRange", "(", "unsigned", "range", ")", "{", "range", "++", ";", "uses", "=", "BitVector", "(", "range", ")", ";", "defs", "=", "BitVector", "(", "range", ")", ";", "}", "</s>" ]

[ "Constructs", "a", "new", "LiveRange", "object", "by", "copying", "segments", "and", "valnos", "from", "another", "LiveRange", "." ]

[ "Patmos" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "joinRegisterPartsIntoValue", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "const", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "EVT", "ValueVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "assert", "(", "(", "ValueVT", "!=", "MVT", "::", "i128", "||", "(", "(", "NumParts", "==", "1", "&&", "PartVT", "==", "MVT", "::", "Untyped", ")", "||", "(", "NumParts", "==", "2", "&&", "PartVT", "==", "MVT", "::", "i64", ")", ")", ")", "&&", "\"Unknown handling of i128 value.\"", ")", ";", "if", "(", "ValueVT", "==", "MVT", "::", "i128", "&&", "NumParts", "==", "1", ")", "return", "lowerGR128ToI128", "(", "DAG", ",", "Parts", "[", "0", "]", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Target-specific", "combining", "of", "register", "parts", "into", "its", "original", "value", "." ]

[ "SystemZ", "SystemZ", "MVT::i128", "1", "MVT::Untyped", "2", "MVT::i64", "\"Unknown handling of i128 value.\"", "MVT::i128", "1", "0" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "TM", "=", "&", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "STI", "=", "TM", "->", "getSubtargetImpl", "(", "F", ")", ";", "TLI", "=", "STI", "->", "getTargetLowering", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "*", "TLIP", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "LibInfo", "=", "TLIP", "?", "&", "TLIP", "->", "getTLI", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "MadeChange", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]